Clover coverage report - JBind Project
Coverage timestamp: Fr Mai 28 2004 11:17:36 CEST
file stats: LOC: 3.438   Methods: 91
NCLOC: 3.429   Classes: 1
This license of Clover is provided to support the development of JBind only. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover.
 
 Source file Conditionals Statements Methods TOTAL
ParserTokenManager.java 30,7% 40,4% 49,5% 37,6%
 1   
 /* Generated By:JavaCC: Do not edit this line. ParserTokenManager.java */
 2   
 package org.jbind.xml.parser;
 3   
 import java.io.*;
 4   
 import java.net.URL;
 5   
 import java.util.*;
 6   
 import org.jbind.message.IMessage;
 7   
 import org.jbind.xml.Config;
 8   
 import org.jbind.xml.base.ILocation;
 9   
 import org.jbind.xml.base.INamespaces;
 10   
 import org.jbind.xml.base.InputSourceLocation;
 11   
 import org.jbind.xml.base.PrefixDeclaration;
 12   
 import org.jbind.xml.core.bridge.IRegEx;
 13   
 import org.jbind.xml.msg.XmlMessages;
 14   
 import org.xml.sax.InputSource;
 15   
 
 16   
 public class ParserTokenManager implements ParserConstants
 17   
 {
 18   
   public  java.io.PrintStream debugStream = System.out;
 19  0
   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
 20  0
 private final int jjStopStringLiteralDfa_11(int pos, long active0)
 21   
 {
 22  0
    switch (pos)
 23   
    {
 24   
       case 0:
 25  0
          if ((active0 & 0x200000L) != 0L)
 26  0
             return 2;
 27  0
          return -1;
 28   
       case 1:
 29  0
          if ((active0 & 0x200000L) != 0L)
 30  0
             return 3;
 31  0
          return -1;
 32   
       default :
 33  0
          return -1;
 34   
    }
 35   
 }
 36  0
 private final int jjStartNfa_11(int pos, long active0)
 37   
 {
 38  0
    return jjMoveNfa_11(jjStopStringLiteralDfa_11(pos, active0), pos + 1);
 39   
 }
 40  58537
 private final int jjStopAtPos(int pos, int kind)
 41   
 {
 42  58537
    jjmatchedKind = kind;
 43  58537
    jjmatchedPos = pos;
 44  58537
    return pos + 1;
 45   
 }
 46  0
 private final int jjStartNfaWithStates_11(int pos, int kind, int state)
 47   
 {
 48  0
    jjmatchedKind = kind;
 49  0
    jjmatchedPos = pos;
 50  0
    try { curChar = input_stream.readChar(); }
 51  0
    catch(java.io.IOException e) { return pos + 1; }
 52  0
    return jjMoveNfa_11(state, pos + 1);
 53   
 }
 54  16
 private final int jjMoveStringLiteralDfa0_11()
 55   
 {
 56  16
    switch(curChar)
 57   
    {
 58   
       case 93:
 59  8
          return jjMoveStringLiteralDfa1_11(0x200000L);
 60   
       default :
 61  8
          return jjMoveNfa_11(5, 0);
 62   
    }
 63   
 }
 64  8
 private final int jjMoveStringLiteralDfa1_11(long active0)
 65   
 {
 66  8
    try { curChar = input_stream.readChar(); }
 67   
    catch(java.io.IOException e) {
 68  0
       jjStopStringLiteralDfa_11(0, active0);
 69  0
       return 1;
 70   
    }
 71  8
    switch(curChar)
 72   
    {
 73   
       case 93:
 74  8
          return jjMoveStringLiteralDfa2_11(active0, 0x200000L);
 75   
       default :
 76  0
          break;
 77   
    }
 78  0
    return jjStartNfa_11(0, active0);
 79   
 }
 80  8
 private final int jjMoveStringLiteralDfa2_11(long old0, long active0)
 81   
 {
 82  8
    if (((active0 &= old0)) == 0L)
 83  0
       return jjStartNfa_11(0, old0); 
 84  8
    try { curChar = input_stream.readChar(); }
 85   
    catch(java.io.IOException e) {
 86  0
       jjStopStringLiteralDfa_11(1, active0);
 87  0
       return 2;
 88   
    }
 89  8
    switch(curChar)
 90   
    {
 91   
       case 62:
 92  8
          if ((active0 & 0x200000L) != 0L)
 93  8
             return jjStopAtPos(2, 21);
 94  0
          break;
 95   
       default :
 96  0
          break;
 97   
    }
 98  0
    return jjStartNfa_11(1, active0);
 99   
 }
 100  481925
 private final void jjCheckNAdd(int state)
 101   
 {
 102  481925
    if (jjrounds[state] != jjround)
 103   
    {
 104  481925
       jjstateSet[jjnewStateCnt++] = state;
 105  481925
       jjrounds[state] = jjround;
 106   
    }
 107   
 }
 108  8453
 private final void jjAddStates(int start, int end)
 109   
 {
 110  8453
    do {
 111  23849
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 112  23849
    } while (start++ != end);
 113   
 }
 114  3780
 private final void jjCheckNAddTwoStates(int state1, int state2)
 115   
 {
 116  3780
    jjCheckNAdd(state1);
 117  3780
    jjCheckNAdd(state2);
 118   
 }
 119  13111
 private final void jjCheckNAddStates(int start, int end)
 120   
 {
 121  13111
    do {
 122  39339
       jjCheckNAdd(jjnextStates[start]);
 123  39339
    } while (start++ != end);
 124   
 }
 125  0
 private final void jjCheckNAddStates(int start)
 126   
 {
 127  0
    jjCheckNAdd(jjnextStates[start]);
 128  0
    jjCheckNAdd(jjnextStates[start + 1]);
 129   
 }
 130   
 static final long[] jjbitVec0 = {
 131   
    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 132   
 };
 133   
 static final long[] jjbitVec2 = {
 134   
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 135   
 };
 136  8
 private final int jjMoveNfa_11(int startState, int curPos)
 137   
 {
 138  8
    int[] nextStates;
 139  8
    int startsAt = 0;
 140  8
    jjnewStateCnt = 5;
 141  8
    int i = 1;
 142  8
    jjstateSet[0] = startState;
 143  8
    int j, kind = 0x7fffffff;
 144  8
    for (;;)
 145   
    {
 146  1664
       if (++jjround == 0x7fffffff)
 147  0
          ReInitRounds();
 148  1664
       if (curChar < 64)
 149   
       {
 150  592
          long l = 1L << curChar;
 151  592
          MatchLoop: do
 152   
          {
 153  1744
             switch(jjstateSet[--i])
 154   
             {
 155   
                case 5:
 156   
                case 0:
 157  584
                   if (kind > 20)
 158  584
                      kind = 20;
 159  584
                   jjCheckNAddStates(0, 2);
 160  584
                   break;
 161   
                case 2:
 162  0
                   if (kind > 20)
 163  0
                      kind = 20;
 164  0
                   jjCheckNAddStates(0, 2);
 165  0
                   break;
 166   
                case 3:
 167  8
                   if ((0xbfffffffffffffffL & l) == 0L)
 168  8
                      break;
 169  0
                   if (kind > 20)
 170  0
                      kind = 20;
 171  0
                   jjCheckNAddStates(0, 2);
 172  0
                   break;
 173  1152
                default : break;
 174   
             }
 175  1744
          } while(i != startsAt);
 176   
       }
 177  1072
       else if (curChar < 128)
 178   
       {
 179  1072
          long l = 1L << (curChar & 077);
 180  1072
          MatchLoop: do
 181   
          {
 182  3208
             switch(jjstateSet[--i])
 183   
             {
 184   
                case 5:
 185  0
                   if ((0xffffffffdfffffffL & l) != 0L)
 186   
                   {
 187  0
                      if (kind > 20)
 188  0
                         kind = 20;
 189  0
                      jjCheckNAddStates(0, 2);
 190   
                   }
 191  0
                   else if (curChar == 93)
 192  0
                      jjstateSet[jjnewStateCnt++] = 2;
 193  0
                   if (curChar == 93)
 194  0
                      jjCheckNAdd(0);
 195  0
                   break;
 196   
                case 2:
 197  8
                   if ((0xffffffffdfffffffL & l) != 0L)
 198   
                   {
 199  0
                      if (kind > 20)
 200  0
                         kind = 20;
 201  0
                      jjCheckNAddStates(0, 2);
 202   
                   }
 203  8
                   else if (curChar == 93)
 204  8
                      jjstateSet[jjnewStateCnt++] = 3;
 205  8
                   break;
 206   
                case 0:
 207  1072
                   if ((0xffffffffdfffffffL & l) == 0L)
 208  16
                      break;
 209  1056
                   if (kind > 20)
 210  1056
                      kind = 20;
 211  1056
                   jjCheckNAddStates(0, 2);
 212  1056
                   break;
 213   
                case 1:
 214  1064
                   if (curChar == 93)
 215  8
                      jjCheckNAdd(0);
 216  1064
                   break;
 217   
                case 3:
 218  0
                   if (kind > 20)
 219  0
                      kind = 20;
 220  0
                   jjCheckNAddStates(0, 2);
 221  0
                   break;
 222   
                case 4:
 223  1064
                   if (curChar == 93)
 224  8
                      jjstateSet[jjnewStateCnt++] = 2;
 225  1064
                   break;
 226  0
                default : break;
 227   
             }
 228  3208
          } while(i != startsAt);
 229   
       }
 230   
       else
 231   
       {
 232  0
          int hiByte = (int)(curChar >> 8);
 233  0
          int i1 = hiByte >> 6;
 234  0
          long l1 = 1L << (hiByte & 077);
 235  0
          int i2 = (curChar & 0xff) >> 6;
 236  0
          long l2 = 1L << (curChar & 077);
 237  0
          MatchLoop: do
 238   
          {
 239  0
             switch(jjstateSet[--i])
 240   
             {
 241   
                case 5:
 242   
                case 0:
 243   
                case 3:
 244  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 245  0
                      break;
 246  0
                   if (kind > 20)
 247  0
                      kind = 20;
 248  0
                   jjCheckNAddStates(0, 2);
 249  0
                   break;
 250   
                case 2:
 251  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 252  0
                      break;
 253  0
                   if (kind > 20)
 254  0
                      kind = 20;
 255  0
                   jjCheckNAddStates(0, 2);
 256  0
                   break;
 257  0
                default : break;
 258   
             }
 259  0
          } while(i != startsAt);
 260   
       }
 261  1664
       if (kind != 0x7fffffff)
 262   
       {
 263  1640
          jjmatchedKind = kind;
 264  1640
          jjmatchedPos = curPos;
 265  1640
          kind = 0x7fffffff;
 266   
       }
 267  1664
       ++curPos;
 268  ?
       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
 269  8
          return curPos;
 270  1656
       try { curChar = input_stream.readChar(); }
 271  0
       catch(java.io.IOException e) { return curPos; }
 272   
    }
 273   
 }
 274  0
 private final int jjStopStringLiteralDfa_1(int pos, long active0)
 275   
 {
 276  0
    switch (pos)
 277   
    {
 278   
       default :
 279  0
          return -1;
 280   
    }
 281   
 }
 282  0
 private final int jjStartNfa_1(int pos, long active0)
 283   
 {
 284  0
    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
 285   
 }
 286  0
 private final int jjStartNfaWithStates_1(int pos, int kind, int state)
 287   
 {
 288  0
    jjmatchedKind = kind;
 289  0
    jjmatchedPos = pos;
 290  0
    try { curChar = input_stream.readChar(); }
 291  0
    catch(java.io.IOException e) { return pos + 1; }
 292  0
    return jjMoveNfa_1(state, pos + 1);
 293   
 }
 294  17
 private final int jjMoveStringLiteralDfa0_1()
 295   
 {
 296  17
    switch(curChar)
 297   
    {
 298   
       case 62:
 299  7
          return jjStopAtPos(0, 22);
 300   
       case 91:
 301  3
          return jjStopAtPos(0, 23);
 302   
       default :
 303  7
          return jjMoveNfa_1(1, 0);
 304   
    }
 305   
 }
 306  7
 private final int jjMoveNfa_1(int startState, int curPos)
 307   
 {
 308  7
    int[] nextStates;
 309  7
    int startsAt = 0;
 310  7
    jjnewStateCnt = 16;
 311  7
    int i = 1;
 312  7
    jjstateSet[0] = startState;
 313  7
    int j, kind = 0x7fffffff;
 314  7
    for (;;)
 315   
    {
 316  14
       if (++jjround == 0x7fffffff)
 317  0
          ReInitRounds();
 318  14
       if (curChar < 64)
 319   
       {
 320  11
          long l = 1L << curChar;
 321  11
          MatchLoop: do
 322   
          {
 323  11
             switch(jjstateSet[--i])
 324   
             {
 325   
                case 1:
 326  7
                   if ((0x100002600L & l) != 0L)
 327   
                   {
 328  7
                      if (kind > 1)
 329  7
                         kind = 1;
 330  7
                      jjCheckNAdd(0);
 331   
                   }
 332  0
                   else if (curChar == 60)
 333  0
                      jjAddStates(3, 4);
 334  7
                   break;
 335   
                case 0:
 336  4
                   if ((0x100002600L & l) == 0L)
 337  4
                      break;
 338  0
                   if (kind > 1)
 339  0
                      kind = 1;
 340  0
                   jjCheckNAdd(0);
 341  0
                   break;
 342   
                case 2:
 343  0
                   if (curChar == 45)
 344  0
                      jjCheckNAddTwoStates(3, 4);
 345  0
                   break;
 346   
                case 3:
 347  0
                   if ((0xffffdfffffffffffL & l) != 0L)
 348  0
                      jjCheckNAddStates(5, 7);
 349  0
                   break;
 350   
                case 4:
 351  0
                   if (curChar == 45)
 352  0
                      jjCheckNAdd(3);
 353  0
                   break;
 354   
                case 5:
 355  0
                   if (curChar == 62 && kind > 6)
 356  0
                      kind = 6;
 357  0
                   break;
 358   
                case 6:
 359  0
                   if (curChar == 45)
 360  0
                      jjstateSet[jjnewStateCnt++] = 5;
 361  0
                   break;
 362   
                case 7:
 363  0
                   if (curChar == 45)
 364  0
                      jjstateSet[jjnewStateCnt++] = 6;
 365  0
                   break;
 366   
                case 8:
 367  0
                   if (curChar == 45)
 368  0
                      jjstateSet[jjnewStateCnt++] = 2;
 369  0
                   break;
 370   
                case 9:
 371  0
                   if (curChar == 33)
 372  0
                      jjstateSet[jjnewStateCnt++] = 8;
 373  0
                   break;
 374   
                case 10:
 375  0
                   if (curChar == 63)
 376  0
                      jjCheckNAddTwoStates(11, 12);
 377  0
                   break;
 378   
                case 11:
 379  0
                   if ((0x7fffffffffffffffL & l) != 0L)
 380  0
                      jjCheckNAddStates(8, 10);
 381  0
                   break;
 382   
                case 12:
 383  0
                   if (curChar == 63)
 384  0
                      jjstateSet[jjnewStateCnt++] = 13;
 385  0
                   break;
 386   
                case 13:
 387  0
                   if ((0xbfffffffffffffffL & l) != 0L)
 388  0
                      jjCheckNAddStates(8, 10);
 389  0
                   break;
 390   
                case 14:
 391  0
                   if (curChar == 62 && kind > 7)
 392  0
                      kind = 7;
 393  0
                   break;
 394   
                case 15:
 395  0
                   if (curChar == 63)
 396  0
                      jjstateSet[jjnewStateCnt++] = 14;
 397  0
                   break;
 398  0
                default : break;
 399   
             }
 400  11
          } while(i != startsAt);
 401   
       }
 402  3
       else if (curChar < 128)
 403   
       {
 404  3
          long l = 1L << (curChar & 077);
 405  3
          MatchLoop: do
 406   
          {
 407  3
             switch(jjstateSet[--i])
 408   
             {
 409   
                case 3:
 410  0
                   jjAddStates(5, 7);
 411  0
                   break;
 412   
                case 11:
 413   
                case 13:
 414  0
                   jjCheckNAddStates(8, 10);
 415  0
                   break;
 416  3
                default : break;
 417   
             }
 418  3
          } while(i != startsAt);
 419   
       }
 420   
       else
 421   
       {
 422  0
          int hiByte = (int)(curChar >> 8);
 423  0
          int i1 = hiByte >> 6;
 424  0
          long l1 = 1L << (hiByte & 077);
 425  0
          int i2 = (curChar & 0xff) >> 6;
 426  0
          long l2 = 1L << (curChar & 077);
 427  0
          MatchLoop: do
 428   
          {
 429  0
             switch(jjstateSet[--i])
 430   
             {
 431   
                case 3:
 432  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 433  0
                      jjAddStates(5, 7);
 434  0
                   break;
 435   
                case 11:
 436   
                case 13:
 437  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 438  0
                      jjCheckNAddStates(8, 10);
 439  0
                   break;
 440  0
                default : break;
 441   
             }
 442  0
          } while(i != startsAt);
 443   
       }
 444  14
       if (kind != 0x7fffffff)
 445   
       {
 446  7
          jjmatchedKind = kind;
 447  7
          jjmatchedPos = curPos;
 448  7
          kind = 0x7fffffff;
 449   
       }
 450  14
       ++curPos;
 451  ?
       if ((i = jjnewStateCnt) == (startsAt = 16 - (jjnewStateCnt = startsAt)))
 452  7
          return curPos;
 453  7
       try { curChar = input_stream.readChar(); }
 454  0
       catch(java.io.IOException e) { return curPos; }
 455   
    }
 456   
 }
 457  0
 private final int jjStopStringLiteralDfa_2(int pos, long active0)
 458   
 {
 459  0
    switch (pos)
 460   
    {
 461   
       default :
 462  0
          return -1;
 463   
    }
 464   
 }
 465  0
 private final int jjStartNfa_2(int pos, long active0)
 466   
 {
 467  0
    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
 468   
 }
 469  0
 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
 470   
 {
 471  0
    jjmatchedKind = kind;
 472  0
    jjmatchedPos = pos;
 473  0
    try { curChar = input_stream.readChar(); }
 474  0
    catch(java.io.IOException e) { return pos + 1; }
 475  0
    return jjMoveNfa_2(state, pos + 1);
 476   
 }
 477  288
 private final int jjMoveStringLiteralDfa0_2()
 478   
 {
 479  288
    switch(curChar)
 480   
    {
 481   
       case 93:
 482  3
          return jjStopAtPos(0, 26);
 483   
       default :
 484  285
          return jjMoveNfa_2(1, 0);
 485   
    }
 486   
 }
 487   
 static final long[] jjbitVec3 = {
 488   
    0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
 489   
 };
 490   
 static final long[] jjbitVec4 = {
 491   
    0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
 492   
 };
 493   
 static final long[] jjbitVec5 = {
 494   
    0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
 495   
 };
 496   
 static final long[] jjbitVec6 = {
 497   
    0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
 498   
 };
 499   
 static final long[] jjbitVec7 = {
 500   
    0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
 501   
 };
 502   
 static final long[] jjbitVec8 = {
 503   
    0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
 504   
 };
 505   
 static final long[] jjbitVec9 = {
 506   
    0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
 507   
 };
 508   
 static final long[] jjbitVec10 = {
 509   
    0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
 510   
 };
 511   
 static final long[] jjbitVec11 = {
 512   
    0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
 513   
 };
 514   
 static final long[] jjbitVec12 = {
 515   
    0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
 516   
 };
 517   
 static final long[] jjbitVec13 = {
 518   
    0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
 519   
 };
 520   
 static final long[] jjbitVec14 = {
 521   
    0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
 522   
 };
 523   
 static final long[] jjbitVec15 = {
 524   
    0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
 525   
 };
 526   
 static final long[] jjbitVec16 = {
 527   
    0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
 528   
 };
 529   
 static final long[] jjbitVec17 = {
 530   
    0x0L, 0x3fffffffeffL, 0x0L, 0x0L
 531   
 };
 532   
 static final long[] jjbitVec18 = {
 533   
    0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
 534   
 };
 535   
 static final long[] jjbitVec19 = {
 536   
    0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
 537   
 };
 538   
 static final long[] jjbitVec20 = {
 539   
    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
 540   
 };
 541   
 static final long[] jjbitVec21 = {
 542   
    0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
 543   
 };
 544   
 static final long[] jjbitVec22 = {
 545   
    0x4c4000000000L, 0x0L, 0x7L, 0x0L
 546   
 };
 547   
 static final long[] jjbitVec23 = {
 548   
    0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
 549   
 };
 550   
 static final long[] jjbitVec24 = {
 551   
    0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
 552   
 };
 553   
 static final long[] jjbitVec25 = {
 554   
    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
 555   
 };
 556   
 static final long[] jjbitVec26 = {
 557   
    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
 558   
 };
 559   
 static final long[] jjbitVec27 = {
 560   
    0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
 561   
 };
 562   
 static final long[] jjbitVec28 = {
 563   
    0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
 564   
 };
 565   
 static final long[] jjbitVec29 = {
 566   
    0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
 567   
 };
 568   
 static final long[] jjbitVec30 = {
 569   
    0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
 570   
 };
 571   
 static final long[] jjbitVec31 = {
 572   
    0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
 573   
 };
 574   
 static final long[] jjbitVec32 = {
 575   
    0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
 576   
 };
 577   
 static final long[] jjbitVec33 = {
 578   
    0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
 579   
 };
 580   
 static final long[] jjbitVec34 = {
 581   
    0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
 582   
 };
 583   
 static final long[] jjbitVec35 = {
 584   
    0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
 585   
 };
 586   
 static final long[] jjbitVec36 = {
 587   
    0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
 588   
 };
 589   
 static final long[] jjbitVec37 = {
 590   
    0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
 591   
 };
 592   
 static final long[] jjbitVec38 = {
 593   
    0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
 594   
 };
 595   
 static final long[] jjbitVec39 = {
 596   
    0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
 597   
 };
 598   
 static final long[] jjbitVec40 = {
 599   
    0x0L, 0x0L, 0x0L, 0x21fff0000L
 600   
 };
 601   
 static final long[] jjbitVec41 = {
 602   
    0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
 603   
 };
 604  285
 private final int jjMoveNfa_2(int startState, int curPos)
 605   
 {
 606  285
    int[] nextStates;
 607  285
    int startsAt = 0;
 608  285
    jjnewStateCnt = 96;
 609  285
    int i = 1;
 610  285
    jjstateSet[0] = startState;
 611  285
    int j, kind = 0x7fffffff;
 612  285
    for (;;)
 613   
    {
 614  7893
       if (++jjround == 0x7fffffff)
 615  0
          ReInitRounds();
 616  7893
       if (curChar < 64)
 617   
       {
 618  3318
          long l = 1L << curChar;
 619  3318
          MatchLoop: do
 620   
          {
 621  6135
             switch(jjstateSet[--i])
 622   
             {
 623   
                case 1:
 624  285
                   if ((0x100002600L & l) != 0L)
 625   
                   {
 626  144
                      if (kind > 1)
 627  144
                         kind = 1;
 628  144
                      jjCheckNAdd(0);
 629   
                   }
 630  141
                   else if (curChar == 60)
 631  141
                      jjAddStates(11, 15);
 632  285
                   break;
 633   
                case 0:
 634  882
                   if ((0x100002600L & l) == 0L)
 635  141
                      break;
 636  741
                   if (kind > 1)
 637  741
                      kind = 1;
 638  741
                   jjCheckNAdd(0);
 639  741
                   break;
 640   
                case 2:
 641  9
                   if (curChar == 45)
 642  9
                      jjCheckNAddTwoStates(3, 4);
 643  9
                   break;
 644   
                case 3:
 645  258
                   if ((0xffffdfffffffffffL & l) != 0L)
 646  240
                      jjCheckNAddStates(5, 7);
 647  258
                   break;
 648   
                case 4:
 649  249
                   if (curChar == 45)
 650  9
                      jjCheckNAdd(3);
 651  249
                   break;
 652   
                case 5:
 653  9
                   if (curChar == 62 && kind > 6)
 654  9
                      kind = 6;
 655  9
                   break;
 656   
                case 6:
 657  9
                   if (curChar == 45)
 658  9
                      jjstateSet[jjnewStateCnt++] = 5;
 659  9
                   break;
 660   
                case 7:
 661  240
                   if (curChar == 45)
 662  9
                      jjstateSet[jjnewStateCnt++] = 6;
 663  240
                   break;
 664   
                case 8:
 665  9
                   if (curChar == 45)
 666  9
                      jjstateSet[jjnewStateCnt++] = 2;
 667  9
                   break;
 668   
                case 9:
 669  141
                   if (curChar == 33)
 670  141
                      jjstateSet[jjnewStateCnt++] = 8;
 671  141
                   break;
 672   
                case 10:
 673  141
                   if (curChar == 63)
 674  0
                      jjCheckNAddTwoStates(11, 12);
 675  141
                   break;
 676   
                case 11:
 677  0
                   if ((0x7fffffffffffffffL & l) != 0L)
 678  0
                      jjCheckNAddStates(8, 10);
 679  0
                   break;
 680   
                case 12:
 681  0
                   if (curChar == 63)
 682  0
                      jjstateSet[jjnewStateCnt++] = 13;
 683  0
                   break;
 684   
                case 13:
 685  0
                   if ((0xbfffffffffffffffL & l) != 0L)
 686  0
                      jjCheckNAddStates(8, 10);
 687  0
                   break;
 688   
                case 14:
 689  0
                   if (curChar == 62 && kind > 7)
 690  0
                      kind = 7;
 691  0
                   break;
 692   
                case 15:
 693  0
                   if (curChar == 63)
 694  0
                      jjstateSet[jjnewStateCnt++] = 14;
 695  0
                   break;
 696   
                case 17:
 697  1668
                   if ((0xbfffffffffffffffL & l) != 0L)
 698  1545
                      jjAddStates(16, 17);
 699  1668
                   break;
 700   
                case 18:
 701  1668
                   if (curChar == 62 && kind > 27)
 702  123
                      kind = 27;
 703  1668
                   break;
 704   
                case 25:
 705  141
                   if (curChar == 33)
 706  141
                      jjstateSet[jjnewStateCnt++] = 24;
 707  141
                   break;
 708   
                case 27:
 709  24
                   if ((0xbfffffffffffffffL & l) != 0L)
 710  18
                      jjAddStates(18, 19);
 711  24
                   break;
 712   
                case 28:
 713  24
                   if (curChar == 62 && kind > 28)
 714  6
                      kind = 28;
 715  24
                   break;
 716   
                case 35:
 717  141
                   if (curChar == 33)
 718  141
                      jjstateSet[jjnewStateCnt++] = 34;
 719  141
                   break;
 720   
                case 37:
 721  6
                   if ((0x100002600L & l) != 0L)
 722  3
                      jjCheckNAddStates(20, 22);
 723  6
                   break;
 724   
                case 38:
 725  3
                   if (curChar == 37)
 726  3
                      jjCheckNAdd(39);
 727  3
                   break;
 728   
                case 39:
 729  3
                   if ((0x100002600L & l) != 0L)
 730  3
                      jjCheckNAddTwoStates(39, 40);
 731  3
                   break;
 732   
                case 40:
 733  3
                   if (curChar == 58)
 734  0
                      jjCheckNAddTwoStates(41, 42);
 735  3
                   break;
 736   
                case 41:
 737  3
                   if ((0x7ff600000000000L & l) != 0L)
 738  0
                      jjCheckNAddTwoStates(41, 42);
 739  3
                   break;
 740   
                case 42:
 741  6
                   if ((0x100002600L & l) != 0L)
 742  3
                      jjCheckNAddStates(23, 27);
 743  6
                   break;
 744   
                case 44:
 745  0
                   if ((0x100002600L & l) != 0L)
 746  0
                      jjAddStates(28, 30);
 747  0
                   break;
 748   
                case 45:
 749  0
                   if (curChar == 34)
 750  0
                      jjCheckNAddTwoStates(46, 47);
 751  0
                   break;
 752   
                case 46:
 753  0
                   if ((0xfffffffbffffffffL & l) != 0L)
 754  0
                      jjCheckNAddTwoStates(46, 47);
 755  0
                   break;
 756   
                case 47:
 757  0
                   if (curChar == 34)
 758  0
                      jjCheckNAddTwoStates(48, 53);
 759  0
                   break;
 760   
                case 48:
 761  0
                   if ((0x100002600L & l) != 0L)
 762  0
                      jjCheckNAddTwoStates(48, 57);
 763  0
                   break;
 764   
                case 50:
 765  0
                   if ((0x100002600L & l) != 0L)
 766  0
                      jjAddStates(31, 32);
 767  0
                   break;
 768   
                case 51:
 769  0
                   if (curChar == 58)
 770  0
                      jjCheckNAddTwoStates(52, 53);
 771  0
                   break;
 772   
                case 52:
 773  0
                   if ((0x7ff600000000000L & l) != 0L)
 774  0
                      jjCheckNAddTwoStates(52, 53);
 775  0
                   break;
 776   
                case 53:
 777  3
                   if (curChar == 62 && kind > 29)
 778  3
                      kind = 29;
 779  3
                   break;
 780   
                case 58:
 781  0
                   if (curChar == 39)
 782  0
                      jjCheckNAddTwoStates(59, 60);
 783  0
                   break;
 784   
                case 59:
 785  0
                   if ((0xffffff7fffffffffL & l) != 0L)
 786  0
                      jjCheckNAddTwoStates(59, 60);
 787  0
                   break;
 788   
                case 60:
 789  0
                   if (curChar == 39)
 790  0
                      jjCheckNAddTwoStates(48, 53);
 791  0
                   break;
 792   
                case 67:
 793  0
                   if ((0x100002600L & l) != 0L)
 794  0
                      jjAddStates(33, 35);
 795  0
                   break;
 796   
                case 68:
 797  0
                   if (curChar == 34)
 798  0
                      jjCheckNAddTwoStates(69, 70);
 799  0
                   break;
 800   
                case 69:
 801  0
                   if ((0xfffffffbffffffffL & l) != 0L)
 802  0
                      jjCheckNAddTwoStates(69, 70);
 803  0
                   break;
 804   
                case 70:
 805  0
                   if (curChar == 34)
 806  0
                      jjCheckNAdd(71);
 807  0
                   break;
 808   
                case 71:
 809  0
                   if ((0x100002600L & l) != 0L)
 810  0
                      jjCheckNAddStates(36, 38);
 811  0
                   break;
 812   
                case 72:
 813  0
                   if (curChar == 34)
 814  0
                      jjCheckNAddTwoStates(73, 47);
 815  0
                   break;
 816   
                case 73:
 817  0
                   if ((0xfffffffbffffffffL & l) != 0L)
 818  0
                      jjCheckNAddTwoStates(73, 47);
 819  0
                   break;
 820   
                case 74:
 821  0
                   if (curChar == 39)
 822  0
                      jjCheckNAddTwoStates(75, 60);
 823  0
                   break;
 824   
                case 75:
 825  0
                   if ((0xffffff7fffffffffL & l) != 0L)
 826  0
                      jjCheckNAddTwoStates(75, 60);
 827  0
                   break;
 828   
                case 76:
 829  0
                   if (curChar == 39)
 830  0
                      jjCheckNAddTwoStates(77, 78);
 831  0
                   break;
 832   
                case 77:
 833  0
                   if ((0xffffff7fffffffffL & l) != 0L)
 834  0
                      jjCheckNAddTwoStates(77, 78);
 835  0
                   break;
 836   
                case 78:
 837  0
                   if (curChar == 39)
 838  0
                      jjCheckNAdd(71);
 839  0
                   break;
 840   
                case 84:
 841  3
                   if (curChar == 39)
 842  3
                      jjCheckNAddTwoStates(85, 86);
 843  3
                   break;
 844   
                case 85:
 845  15
                   if ((0xffffff7fffffffffL & l) != 0L)
 846  12
                      jjCheckNAddTwoStates(85, 86);
 847  15
                   break;
 848   
                case 86:
 849  15
                   if (curChar == 39)
 850  3
                      jjCheckNAdd(53);
 851  15
                   break;
 852   
                case 87:
 853  3
                   if (curChar == 34)
 854  0
                      jjCheckNAddTwoStates(88, 89);
 855  3
                   break;
 856   
                case 88:
 857  0
                   if ((0xfffffffbffffffffL & l) != 0L)
 858  0
                      jjCheckNAddTwoStates(88, 89);
 859  0
                   break;
 860   
                case 89:
 861  0
                   if (curChar == 34)
 862  0
                      jjCheckNAdd(53);
 863  0
                   break;
 864   
                case 95:
 865  141
                   if (curChar == 33)
 866  141
                      jjstateSet[jjnewStateCnt++] = 94;
 867  141
                   break;
 868  33
                default : break;
 869   
             }
 870  6135
          } while(i != startsAt);
 871   
       }
 872  4575
       else if (curChar < 128)
 873   
       {
 874  4575
          long l = 1L << (curChar & 077);
 875  4575
          MatchLoop: do
 876   
          {
 877  9171
             switch(jjstateSet[--i])
 878   
             {
 879   
                case 3:
 880  540
                   jjAddStates(5, 7);
 881  540
                   break;
 882   
                case 11:
 883   
                case 13:
 884  0
                   jjCheckNAddStates(8, 10);
 885  0
                   break;
 886   
                case 16:
 887  123
                   if (curChar == 84)
 888  123
                      jjCheckNAddTwoStates(17, 18);
 889  123
                   break;
 890   
                case 17:
 891  2913
                   jjCheckNAddTwoStates(17, 18);
 892  2913
                   break;
 893   
                case 19:
 894  123
                   if (curChar == 83)
 895  123
                      jjstateSet[jjnewStateCnt++] = 16;
 896  123
                   break;
 897   
                case 20:
 898  123
                   if (curChar == 73)
 899  123
                      jjstateSet[jjnewStateCnt++] = 19;
 900  123
                   break;
 901   
                case 21:
 902  123
                   if (curChar == 76)
 903  123
                      jjstateSet[jjnewStateCnt++] = 20;
 904  123
                   break;
 905   
                case 22:
 906  123
                   if (curChar == 84)
 907  123
                      jjstateSet[jjnewStateCnt++] = 21;
 908  123
                   break;
 909   
                case 23:
 910  123
                   if (curChar == 84)
 911  123
                      jjstateSet[jjnewStateCnt++] = 22;
 912  123
                   break;
 913   
                case 24:
 914  132
                   if (curChar == 65)
 915  123
                      jjstateSet[jjnewStateCnt++] = 23;
 916  132
                   break;
 917   
                case 26:
 918  6
                   if (curChar == 84)
 919  6
                      jjCheckNAddTwoStates(27, 28);
 920  6
                   break;
 921   
                case 27:
 922  105
                   jjCheckNAddTwoStates(27, 28);
 923  105
                   break;
 924   
                case 29:
 925  6
                   if (curChar == 78)
 926  6
                      jjstateSet[jjnewStateCnt++] = 26;
 927  6
                   break;
 928   
                case 30:
 929  6
                   if (curChar == 69)
 930  6
                      jjstateSet[jjnewStateCnt++] = 29;
 931  6
                   break;
 932   
                case 31:
 933  6
                   if (curChar == 77)
 934  6
                      jjstateSet[jjnewStateCnt++] = 30;
 935  6
                   break;
 936   
                case 32:
 937  6
                   if (curChar == 69)
 938  6
                      jjstateSet[jjnewStateCnt++] = 31;
 939  6
                   break;
 940   
                case 33:
 941  9
                   if (curChar == 76)
 942  6
                      jjstateSet[jjnewStateCnt++] = 32;
 943  9
                   break;
 944   
                case 34:
 945  132
                   if (curChar == 69)
 946  9
                      jjstateSet[jjnewStateCnt++] = 33;
 947  132
                   break;
 948   
                case 36:
 949  3
                   if (curChar == 89)
 950  3
                      jjstateSet[jjnewStateCnt++] = 37;
 951  3
                   break;
 952   
                case 40:
 953   
                case 41:
 954  33
                   if ((0x7fffffe87fffffeL & l) != 0L)
 955  33
                      jjCheckNAddTwoStates(41, 42);
 956  33
                   break;
 957   
                case 43:
 958  0
                   if (curChar == 77)
 959  0
                      jjstateSet[jjnewStateCnt++] = 44;
 960  0
                   break;
 961   
                case 46:
 962  0
                   jjCheckNAddTwoStates(46, 47);
 963  0
                   break;
 964   
                case 49:
 965  0
                   if (curChar == 65)
 966  0
                      jjstateSet[jjnewStateCnt++] = 50;
 967  0
                   break;
 968   
                case 51:
 969   
                case 52:
 970  0
                   if ((0x7fffffe87fffffeL & l) != 0L)
 971  0
                      jjCheckNAddTwoStates(52, 53);
 972  0
                   break;
 973   
                case 54:
 974  0
                   if (curChar == 84)
 975  0
                      jjstateSet[jjnewStateCnt++] = 49;
 976  0
                   break;
 977   
                case 55:
 978  0
                   if (curChar == 65)
 979  0
                      jjstateSet[jjnewStateCnt++] = 54;
 980  0
                   break;
 981   
                case 56:
 982  0
                   if (curChar == 68)
 983  0
                      jjstateSet[jjnewStateCnt++] = 55;
 984  0
                   break;
 985   
                case 57:
 986  0
                   if (curChar == 78)
 987  0
                      jjstateSet[jjnewStateCnt++] = 56;
 988  0
                   break;
 989   
                case 59:
 990  0
                   jjCheckNAddTwoStates(59, 60);
 991  0
                   break;
 992   
                case 61:
 993  0
                   if (curChar == 69)
 994  0
                      jjstateSet[jjnewStateCnt++] = 43;
 995  0
                   break;
 996   
                case 62:
 997  0
                   if (curChar == 84)
 998  0
                      jjstateSet[jjnewStateCnt++] = 61;
 999  0
                   break;
 1000   
                case 63:
 1001  0
                   if (curChar == 83)
 1002  0
                      jjstateSet[jjnewStateCnt++] = 62;
 1003  0
                   break;
 1004   
                case 64:
 1005  0
                   if (curChar == 89)
 1006  0
                      jjstateSet[jjnewStateCnt++] = 63;
 1007  0
                   break;
 1008   
                case 65:
 1009  0
                   if (curChar == 83)
 1010  0
                      jjstateSet[jjnewStateCnt++] = 64;
 1011  0
                   break;
 1012   
                case 66:
 1013  0
                   if (curChar == 67)
 1014  0
                      jjstateSet[jjnewStateCnt++] = 67;
 1015  0
                   break;
 1016   
                case 69:
 1017  0
                   jjAddStates(39, 40);
 1018  0
                   break;
 1019   
                case 73:
 1020  0
                   jjCheckNAddTwoStates(73, 47);
 1021  0
                   break;
 1022   
                case 75:
 1023  0
                   jjCheckNAddTwoStates(75, 60);
 1024  0
                   break;
 1025   
                case 77:
 1026  0
                   jjAddStates(41, 42);
 1027  0
                   break;
 1028   
                case 79:
 1029  0
                   if (curChar == 73)
 1030  0
                      jjstateSet[jjnewStateCnt++] = 66;
 1031  0
                   break;
 1032   
                case 80:
 1033  0
                   if (curChar == 76)
 1034  0
                      jjstateSet[jjnewStateCnt++] = 79;
 1035  0
                   break;
 1036   
                case 81:
 1037  0
                   if (curChar == 66)
 1038  0
                      jjstateSet[jjnewStateCnt++] = 80;
 1039  0
                   break;
 1040   
                case 82:
 1041  0
                   if (curChar == 85)
 1042  0
                      jjstateSet[jjnewStateCnt++] = 81;
 1043  0
                   break;
 1044   
                case 83:
 1045  0
                   if (curChar == 80)
 1046  0
                      jjstateSet[jjnewStateCnt++] = 82;
 1047  0
                   break;
 1048   
                case 85:
 1049  60
                   jjAddStates(43, 44);
 1050  60
                   break;
 1051   
                case 88:
 1052  0
                   jjAddStates(45, 46);
 1053  0
                   break;
 1054   
                case 90:
 1055  3
                   if (curChar == 84)
 1056  3
                      jjstateSet[jjnewStateCnt++] = 36;
 1057  3
                   break;
 1058   
                case 91:
 1059  3
                   if (curChar == 73)
 1060  3
                      jjstateSet[jjnewStateCnt++] = 90;
 1061  3
                   break;
 1062   
                case 92:
 1063  3
                   if (curChar == 84)
 1064  3
                      jjstateSet[jjnewStateCnt++] = 91;
 1065  3
                   break;
 1066   
                case 93:
 1067  9
                   if (curChar == 78)
 1068  3
                      jjstateSet[jjnewStateCnt++] = 92;
 1069  9
                   break;
 1070   
                case 94:
 1071  132
                   if (curChar == 69)
 1072  9
                      jjstateSet[jjnewStateCnt++] = 93;
 1073  132
                   break;
 1074  4326
                default : break;
 1075   
             }
 1076  9171
          } while(i != startsAt);
 1077   
       }
 1078   
       else
 1079   
       {
 1080  0
          int hiByte = (int)(curChar >> 8);
 1081  0
          int i1 = hiByte >> 6;
 1082  0
          long l1 = 1L << (hiByte & 077);
 1083  0
          int i2 = (curChar & 0xff) >> 6;
 1084  0
          long l2 = 1L << (curChar & 077);
 1085  0
          MatchLoop: do
 1086   
          {
 1087  0
             switch(jjstateSet[--i])
 1088   
             {
 1089   
                case 3:
 1090  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1091  0
                      jjAddStates(5, 7);
 1092  0
                   break;
 1093   
                case 11:
 1094   
                case 13:
 1095  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1096  0
                      jjCheckNAddStates(8, 10);
 1097  0
                   break;
 1098   
                case 17:
 1099  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1100  0
                      jjAddStates(16, 17);
 1101  0
                   break;
 1102   
                case 27:
 1103  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1104  0
                      jjAddStates(18, 19);
 1105  0
                   break;
 1106   
                case 40:
 1107  0
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
 1108  0
                      jjCheckNAddTwoStates(41, 42);
 1109  0
                   break;
 1110   
                case 41:
 1111  0
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
 1112  0
                      jjCheckNAddTwoStates(41, 42);
 1113  0
                   break;
 1114   
                case 46:
 1115  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1116  0
                      jjCheckNAddTwoStates(46, 47);
 1117  0
                   break;
 1118   
                case 51:
 1119  0
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
 1120  0
                      jjCheckNAddTwoStates(52, 53);
 1121  0
                   break;
 1122   
                case 52:
 1123  0
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
 1124  0
                      jjCheckNAddTwoStates(52, 53);
 1125  0
                   break;
 1126   
                case 59:
 1127  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1128  0
                      jjCheckNAddTwoStates(59, 60);
 1129  0
                   break;
 1130   
                case 69:
 1131  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1132  0
                      jjAddStates(39, 40);
 1133  0
                   break;
 1134   
                case 73:
 1135  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1136  0
                      jjCheckNAddTwoStates(73, 47);
 1137  0
                   break;
 1138   
                case 75:
 1139  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1140  0
                      jjCheckNAddTwoStates(75, 60);
 1141  0
                   break;
 1142   
                case 77:
 1143  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1144  0
                      jjAddStates(41, 42);
 1145  0
                   break;
 1146   
                case 85:
 1147  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1148  0
                      jjAddStates(43, 44);
 1149  0
                   break;
 1150   
                case 88:
 1151  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1152  0
                      jjAddStates(45, 46);
 1153  0
                   break;
 1154  0
                default : break;
 1155   
             }
 1156  0
          } while(i != startsAt);
 1157   
       }
 1158  7893
       if (kind != 0x7fffffff)
 1159   
       {
 1160  1026
          jjmatchedKind = kind;
 1161  1026
          jjmatchedPos = curPos;
 1162  1026
          kind = 0x7fffffff;
 1163   
       }
 1164  7893
       ++curPos;
 1165  ?
       if ((i = jjnewStateCnt) == (startsAt = 96 - (jjnewStateCnt = startsAt)))
 1166  285
          return curPos;
 1167  7608
       try { curChar = input_stream.readChar(); }
 1168  0
       catch(java.io.IOException e) { return curPos; }
 1169   
    }
 1170   
 }
 1171  0
 private final int jjMoveStringLiteralDfa0_6()
 1172   
 {
 1173  0
    return jjMoveNfa_6(0, 0);
 1174   
 }
 1175  0
 private final int jjMoveNfa_6(int startState, int curPos)
 1176   
 {
 1177  0
    int[] nextStates;
 1178  0
    int startsAt = 0;
 1179  0
    jjnewStateCnt = 1;
 1180  0
    int i = 1;
 1181  0
    jjstateSet[0] = startState;
 1182  0
    int j, kind = 0x7fffffff;
 1183  0
    for (;;)
 1184   
    {
 1185  0
       if (++jjround == 0x7fffffff)
 1186  0
          ReInitRounds();
 1187  0
       if (curChar < 64)
 1188   
       {
 1189  0
          long l = 1L << curChar;
 1190  0
          MatchLoop: do
 1191   
          {
 1192  0
             switch(jjstateSet[--i])
 1193   
             {
 1194   
                case 0:
 1195  0
                   if ((0x100002600L & l) == 0L)
 1196  0
                      break;
 1197  0
                   kind = 5;
 1198  0
                   jjstateSet[jjnewStateCnt++] = 0;
 1199  0
                   break;
 1200  0
                default : break;
 1201   
             }
 1202  0
          } while(i != startsAt);
 1203   
       }
 1204  0
       else if (curChar < 128)
 1205   
       {
 1206  0
          long l = 1L << (curChar & 077);
 1207  0
          MatchLoop: do
 1208   
          {
 1209  0
             switch(jjstateSet[--i])
 1210   
             {
 1211  0
                default : break;
 1212   
             }
 1213  0
          } while(i != startsAt);
 1214   
       }
 1215   
       else
 1216   
       {
 1217  0
          int hiByte = (int)(curChar >> 8);
 1218  0
          int i1 = hiByte >> 6;
 1219  0
          long l1 = 1L << (hiByte & 077);
 1220  0
          int i2 = (curChar & 0xff) >> 6;
 1221  0
          long l2 = 1L << (curChar & 077);
 1222  0
          MatchLoop: do
 1223   
          {
 1224  0
             switch(jjstateSet[--i])
 1225   
             {
 1226  0
                default : break;
 1227   
             }
 1228  0
          } while(i != startsAt);
 1229   
       }
 1230  0
       if (kind != 0x7fffffff)
 1231   
       {
 1232  0
          jjmatchedKind = kind;
 1233  0
          jjmatchedPos = curPos;
 1234  0
          kind = 0x7fffffff;
 1235   
       }
 1236  0
       ++curPos;
 1237  0
       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
 1238  0
          return curPos;
 1239  0
       try { curChar = input_stream.readChar(); }
 1240  0
       catch(java.io.IOException e) { return curPos; }
 1241   
    }
 1242   
 }
 1243  0
 private final int jjMoveStringLiteralDfa0_9()
 1244   
 {
 1245  0
    return 1;
 1246   
 }
 1247  543
 private final int jjStopStringLiteralDfa_4(int pos, long active0)
 1248   
 {
 1249  543
    switch (pos)
 1250   
    {
 1251   
       case 0:
 1252  543
          if ((active0 & 0x14L) != 0L)
 1253  543
             return 44;
 1254  0
          return -1;
 1255   
       case 1:
 1256  0
          if ((active0 & 0x4L) != 0L)
 1257  0
             return 59;
 1258  0
          return -1;
 1259   
       case 2:
 1260  0
          if ((active0 & 0x4L) != 0L)
 1261  0
             return 60;
 1262  0
          return -1;
 1263   
       case 3:
 1264  0
          if ((active0 & 0x4L) != 0L)
 1265  0
             return 60;
 1266  0
          return -1;
 1267   
       default :
 1268  0
          return -1;
 1269   
    }
 1270   
 }
 1271  543
 private final int jjStartNfa_4(int pos, long active0)
 1272   
 {
 1273  543
    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
 1274   
 }
 1275  372
 private final int jjStartNfaWithStates_4(int pos, int kind, int state)
 1276   
 {
 1277  372
    jjmatchedKind = kind;
 1278  372
    jjmatchedPos = pos;
 1279  372
    try { curChar = input_stream.readChar(); }
 1280  0
    catch(java.io.IOException e) { return pos + 1; }
 1281  372
    return jjMoveNfa_4(state, pos + 1);
 1282   
 }
 1283  1427
 private final int jjMoveStringLiteralDfa0_4()
 1284   
 {
 1285  1427
    switch(curChar)
 1286   
    {
 1287   
       case 60:
 1288  915
          jjmatchedKind = 4;
 1289  915
          return jjMoveStringLiteralDfa1_4(0x4L);
 1290   
       default :
 1291  512
          return jjMoveNfa_4(1, 0);
 1292   
    }
 1293   
 }
 1294  915
 private final int jjMoveStringLiteralDfa1_4(long active0)
 1295   
 {
 1296  915
    try { curChar = input_stream.readChar(); }
 1297   
    catch(java.io.IOException e) {
 1298  0
       jjStopStringLiteralDfa_4(0, active0);
 1299  0
       return 1;
 1300   
    }
 1301  915
    switch(curChar)
 1302   
    {
 1303   
       case 63:
 1304  372
          return jjMoveStringLiteralDfa2_4(active0, 0x4L);
 1305   
       default :
 1306  543
          break;
 1307   
    }
 1308  543
    return jjStartNfa_4(0, active0);
 1309   
 }
 1310  372
 private final int jjMoveStringLiteralDfa2_4(long old0, long active0)
 1311   
 {
 1312  372
    if (((active0 &= old0)) == 0L)
 1313  0
       return jjStartNfa_4(0, old0); 
 1314  372
    try { curChar = input_stream.readChar(); }
 1315   
    catch(java.io.IOException e) {
 1316  0
       jjStopStringLiteralDfa_4(1, active0);
 1317  0
       return 2;
 1318   
    }
 1319  372
    switch(curChar)
 1320   
    {
 1321   
       case 120:
 1322  372
          return jjMoveStringLiteralDfa3_4(active0, 0x4L);
 1323   
       default :
 1324  0
          break;
 1325   
    }
 1326  0
    return jjStartNfa_4(1, active0);
 1327   
 }
 1328  372
 private final int jjMoveStringLiteralDfa3_4(long old0, long active0)
 1329   
 {
 1330  372
    if (((active0 &= old0)) == 0L)
 1331  0
       return jjStartNfa_4(1, old0); 
 1332  372
    try { curChar = input_stream.readChar(); }
 1333   
    catch(java.io.IOException e) {
 1334  0
       jjStopStringLiteralDfa_4(2, active0);
 1335  0
       return 3;
 1336   
    }
 1337  372
    switch(curChar)
 1338   
    {
 1339   
       case 109:
 1340  372
          return jjMoveStringLiteralDfa4_4(active0, 0x4L);
 1341   
       default :
 1342  0
          break;
 1343   
    }
 1344  0
    return jjStartNfa_4(2, active0);
 1345   
 }
 1346  372
 private final int jjMoveStringLiteralDfa4_4(long old0, long active0)
 1347   
 {
 1348  372
    if (((active0 &= old0)) == 0L)
 1349  0
       return jjStartNfa_4(2, old0); 
 1350  372
    try { curChar = input_stream.readChar(); }
 1351   
    catch(java.io.IOException e) {
 1352  0
       jjStopStringLiteralDfa_4(3, active0);
 1353  0
       return 4;
 1354   
    }
 1355  372
    switch(curChar)
 1356   
    {
 1357   
       case 108:
 1358  372
          if ((active0 & 0x4L) != 0L)
 1359  372
             return jjStartNfaWithStates_4(4, 2, 60);
 1360  0
          break;
 1361   
       default :
 1362  0
          break;
 1363   
    }
 1364  0
    return jjStartNfa_4(3, active0);
 1365   
 }
 1366  1427
 private final int jjMoveNfa_4(int startState, int curPos)
 1367   
 {
 1368  1427
    int[] nextStates;
 1369  1427
    int startsAt = 0;
 1370  1427
    jjnewStateCnt = 59;
 1371  1427
    int i = 1;
 1372  1427
    jjstateSet[0] = startState;
 1373  1427
    int j, kind = 0x7fffffff;
 1374  1427
    for (;;)
 1375   
    {
 1376  16202
       if (++jjround == 0x7fffffff)
 1377  0
          ReInitRounds();
 1378  16202
       if (curChar < 64)
 1379   
       {
 1380  8165
          long l = 1L << curChar;
 1381  8165
          MatchLoop: do
 1382   
          {
 1383  19018
             switch(jjstateSet[--i])
 1384   
             {
 1385   
                case 44:
 1386  76
                   if (curChar == 33)
 1387  76
                      jjstateSet[jjnewStateCnt++] = 51;
 1388  0
                   else if (curChar == 63)
 1389  0
                      jjCheckNAddTwoStates(54, 55);
 1390  76
                   if (curChar == 33)
 1391  76
                      jjstateSet[jjnewStateCnt++] = 43;
 1392  76
                   break;
 1393   
                case 1:
 1394  512
                   if ((0x100002600L & l) != 0L)
 1395   
                   {
 1396  512
                      if (kind > 5)
 1397  512
                         kind = 5;
 1398  512
                      jjCheckNAdd(0);
 1399   
                   }
 1400  0
                   else if (curChar == 60)
 1401  0
                      jjAddStates(47, 49);
 1402  512
                   break;
 1403   
                case 60:
 1404  372
                   if ((0x7fffffffffffffffL & l) != 0L)
 1405  372
                      jjCheckNAddStates(50, 52);
 1406  0
                   else if (curChar == 63)
 1407  0
                      jjstateSet[jjnewStateCnt++] = 57;
 1408  372
                   if (curChar == 63)
 1409  0
                      jjstateSet[jjnewStateCnt++] = 56;
 1410  372
                   break;
 1411   
                case 59:
 1412  0
                   if ((0x7fffffffffffffffL & l) != 0L)
 1413  0
                      jjCheckNAddStates(50, 52);
 1414  0
                   else if (curChar == 63)
 1415  0
                      jjstateSet[jjnewStateCnt++] = 56;
 1416  0
                   break;
 1417   
                case 0:
 1418  1243
                   if ((0x100002600L & l) == 0L)
 1419  512
                      break;
 1420  731
                   if (kind > 5)
 1421  731
                      kind = 5;
 1422  731
                   jjCheckNAdd(0);
 1423  731
                   break;
 1424   
                case 3:
 1425  7
                   if ((0x100002600L & l) != 0L)
 1426  7
                      jjAddStates(53, 54);
 1427  7
                   break;
 1428   
                case 4:
 1429  0
                   if (curChar != 58)
 1430  0
                      break;
 1431  0
                   if (kind > 3)
 1432  0
                      kind = 3;
 1433  0
                   jjCheckNAddTwoStates(5, 6);
 1434  0
                   break;
 1435   
                case 5:
 1436  14
                   if ((0x7ff600000000000L & l) == 0L)
 1437  7
                      break;
 1438  7
                   if (kind > 3)
 1439  7
                      kind = 3;
 1440  7
                   jjCheckNAddTwoStates(5, 6);
 1441  7
                   break;
 1442   
                case 6:
 1443  14
                   if ((0x100002600L & l) != 0L)
 1444  7
                      jjCheckNAddStates(55, 57);
 1445  14
                   break;
 1446   
                case 8:
 1447  0
                   if ((0x100002600L & l) != 0L)
 1448  0
                      jjAddStates(58, 60);
 1449  0
                   break;
 1450   
                case 9:
 1451  0
                   if (curChar == 34)
 1452  0
                      jjCheckNAddTwoStates(10, 11);
 1453  0
                   break;
 1454   
                case 10:
 1455  0
                   if ((0xfffffffbffffffffL & l) != 0L)
 1456  0
                      jjCheckNAddTwoStates(10, 11);
 1457  0
                   break;
 1458   
                case 11:
 1459  14
                   if (curChar == 34 && kind > 3)
 1460  7
                      kind = 3;
 1461  14
                   break;
 1462   
                case 12:
 1463  0
                   if (curChar == 39)
 1464  0
                      jjCheckNAddTwoStates(13, 14);
 1465  0
                   break;
 1466   
                case 13:
 1467  0
                   if ((0xffffff7fffffffffL & l) != 0L)
 1468  0
                      jjCheckNAddTwoStates(13, 14);
 1469  0
                   break;
 1470   
                case 14:
 1471  0
                   if (curChar == 39 && kind > 3)
 1472  0
                      kind = 3;
 1473  0
                   break;
 1474   
                case 21:
 1475  14
                   if ((0x100002600L & l) != 0L)
 1476  7
                      jjAddStates(61, 63);
 1477  14
                   break;
 1478   
                case 22:
 1479  7
                   if (curChar == 34)
 1480  7
                      jjCheckNAddTwoStates(23, 24);
 1481  7
                   break;
 1482   
                case 23:
 1483  119
                   if ((0xfffffffbffffffffL & l) != 0L)
 1484  112
                      jjCheckNAddTwoStates(23, 24);
 1485  119
                   break;
 1486   
                case 24:
 1487  119
                   if (curChar == 34)
 1488  7
                      jjCheckNAdd(25);
 1489  119
                   break;
 1490   
                case 25:
 1491  14
                   if ((0x100002600L & l) != 0L)
 1492  7
                      jjCheckNAddStates(64, 66);
 1493  14
                   break;
 1494   
                case 26:
 1495  7
                   if (curChar == 34)
 1496  7
                      jjCheckNAddTwoStates(27, 11);
 1497  7
                   break;
 1498   
                case 27:
 1499  14
                   if ((0xfffffffbffffffffL & l) != 0L)
 1500  7
                      jjCheckNAddTwoStates(27, 11);
 1501  14
                   break;
 1502   
                case 28:
 1503  7
                   if (curChar == 39)
 1504  0
                      jjCheckNAddTwoStates(29, 14);
 1505  7
                   break;
 1506   
                case 29:
 1507  0
                   if ((0xffffff7fffffffffL & l) != 0L)
 1508  0
                      jjCheckNAddTwoStates(29, 14);
 1509  0
                   break;
 1510   
                case 30:
 1511  7
                   if (curChar == 39)
 1512  0
                      jjCheckNAddTwoStates(31, 32);
 1513  7
                   break;
 1514   
                case 31:
 1515  0
                   if ((0xffffff7fffffffffL & l) != 0L)
 1516  0
                      jjCheckNAddTwoStates(31, 32);
 1517  0
                   break;
 1518   
                case 32:
 1519  0
                   if (curChar == 39)
 1520  0
                      jjCheckNAdd(25);
 1521  0
                   break;
 1522   
                case 45:
 1523  69
                   if (curChar == 45)
 1524  69
                      jjCheckNAddTwoStates(46, 47);
 1525  69
                   break;
 1526   
                case 46:
 1527  1524
                   if ((0xffffdfffffffffffL & l) != 0L)
 1528  1354
                      jjCheckNAddStates(67, 69);
 1529  1524
                   break;
 1530   
                case 47:
 1531  1428
                   if (curChar == 45)
 1532  101
                      jjCheckNAdd(46);
 1533  1428
                   break;
 1534   
                case 48:
 1535  69
                   if (curChar == 62 && kind > 6)
 1536  69
                      kind = 6;
 1537  69
                   break;
 1538   
                case 49:
 1539  96
                   if (curChar == 45)
 1540  69
                      jjstateSet[jjnewStateCnt++] = 48;
 1541  96
                   break;
 1542   
                case 50:
 1543  1359
                   if (curChar == 45)
 1544  101
                      jjstateSet[jjnewStateCnt++] = 49;
 1545  1359
                   break;
 1546   
                case 51:
 1547  69
                   if (curChar == 45)
 1548  69
                      jjstateSet[jjnewStateCnt++] = 45;
 1549  69
                   break;
 1550   
                case 52:
 1551  0
                   if (curChar == 33)
 1552  0
                      jjstateSet[jjnewStateCnt++] = 51;
 1553  0
                   break;
 1554   
                case 53:
 1555  0
                   if (curChar == 63)
 1556  0
                      jjCheckNAddTwoStates(54, 55);
 1557  0
                   break;
 1558   
                case 54:
 1559  3677
                   if ((0x7fffffffffffffffL & l) != 0L)
 1560  3305
                      jjCheckNAddStates(50, 52);
 1561  3677
                   break;
 1562   
                case 55:
 1563  3677
                   if (curChar == 63)
 1564  372
                      jjstateSet[jjnewStateCnt++] = 56;
 1565  3677
                   break;
 1566   
                case 56:
 1567  372
                   if ((0xbfffffffffffffffL & l) != 0L)
 1568  0
                      jjCheckNAddStates(50, 52);
 1569  372
                   break;
 1570   
                case 57:
 1571  372
                   if (curChar == 62 && kind > 7)
 1572  372
                      kind = 7;
 1573  372
                   break;
 1574   
                case 58:
 1575  3677
                   if (curChar == 63)
 1576  372
                      jjstateSet[jjnewStateCnt++] = 57;
 1577  3677
                   break;
 1578  69
                default : break;
 1579   
             }
 1580  19018
          } while(i != startsAt);
 1581   
       }
 1582  8037
       else if (curChar < 128)
 1583   
       {
 1584  8037
          long l = 1L << (curChar & 077);
 1585  8037
          MatchLoop: do
 1586   
          {
 1587  22755
             switch(jjstateSet[--i])
 1588   
             {
 1589   
                case 60:
 1590   
                case 54:
 1591   
                case 56:
 1592  4287
                   jjCheckNAddStates(50, 52);
 1593  4287
                   break;
 1594   
                case 59:
 1595  0
                   jjCheckNAddStates(50, 52);
 1596  0
                   break;
 1597   
                case 2:
 1598  7
                   if (curChar == 69)
 1599  7
                      jjstateSet[jjnewStateCnt++] = 3;
 1600  7
                   break;
 1601   
                case 4:
 1602   
                case 5:
 1603  60
                   if ((0x7fffffe87fffffeL & l) == 0L)
 1604  0
                      break;
 1605  60
                   if (kind > 3)
 1606  60
                      kind = 3;
 1607  60
                   jjCheckNAddTwoStates(5, 6);
 1608  60
                   break;
 1609   
                case 7:
 1610  0
                   if (curChar == 77)
 1611  0
                      jjstateSet[jjnewStateCnt++] = 8;
 1612  0
                   break;
 1613   
                case 10:
 1614  0
                   jjCheckNAddTwoStates(10, 11);
 1615  0
                   break;
 1616   
                case 13:
 1617  0
                   jjCheckNAddTwoStates(13, 14);
 1618  0
                   break;
 1619   
                case 15:
 1620  0
                   if (curChar == 69)
 1621  0
                      jjstateSet[jjnewStateCnt++] = 7;
 1622  0
                   break;
 1623   
                case 16:
 1624  0
                   if (curChar == 84)
 1625  0
                      jjstateSet[jjnewStateCnt++] = 15;
 1626  0
                   break;
 1627   
                case 17:
 1628  0
                   if (curChar == 83)
 1629  0
                      jjstateSet[jjnewStateCnt++] = 16;
 1630  0
                   break;
 1631   
                case 18:
 1632  0
                   if (curChar == 89)
 1633  0
                      jjstateSet[jjnewStateCnt++] = 17;
 1634  0
                   break;
 1635   
                case 19:
 1636  7
                   if (curChar == 83)
 1637  0
                      jjstateSet[jjnewStateCnt++] = 18;
 1638  7
                   break;
 1639   
                case 20:
 1640  7
                   if (curChar == 67)
 1641  7
                      jjstateSet[jjnewStateCnt++] = 21;
 1642  7
                   break;
 1643   
                case 23:
 1644  112
                   jjAddStates(70, 71);
 1645  112
                   break;
 1646   
                case 27:
 1647  84
                   jjCheckNAddTwoStates(27, 11);
 1648  84
                   break;
 1649   
                case 29:
 1650  0
                   jjCheckNAddTwoStates(29, 14);
 1651  0
                   break;
 1652   
                case 31:
 1653  0
                   jjAddStates(72, 73);
 1654  0
                   break;
 1655   
                case 33:
 1656  7
                   if (curChar == 73)
 1657  7
                      jjstateSet[jjnewStateCnt++] = 20;
 1658  7
                   break;
 1659   
                case 34:
 1660  7
                   if (curChar == 76)
 1661  7
                      jjstateSet[jjnewStateCnt++] = 33;
 1662  7
                   break;
 1663   
                case 35:
 1664  7
                   if (curChar == 66)
 1665  7
                      jjstateSet[jjnewStateCnt++] = 34;
 1666  7
                   break;
 1667   
                case 36:
 1668  7
                   if (curChar == 85)
 1669  7
                      jjstateSet[jjnewStateCnt++] = 35;
 1670  7
                   break;
 1671   
                case 37:
 1672  7
                   if (curChar == 80)
 1673  7
                      jjstateSet[jjnewStateCnt++] = 36;
 1674  7
                   break;
 1675   
                case 38:
 1676  7
                   if (curChar == 80)
 1677  7
                      jjstateSet[jjnewStateCnt++] = 2;
 1678  7
                   break;
 1679   
                case 39:
 1680  7
                   if (curChar == 89)
 1681  7
                      jjstateSet[jjnewStateCnt++] = 38;
 1682  7
                   break;
 1683   
                case 40:
 1684  7
                   if (curChar == 84)
 1685  7
                      jjstateSet[jjnewStateCnt++] = 39;
 1686  7
                   break;
 1687   
                case 41:
 1688  7
                   if (curChar == 67)
 1689  7
                      jjstateSet[jjnewStateCnt++] = 40;
 1690  7
                   break;
 1691   
                case 42:
 1692  7
                   if (curChar == 79)
 1693  7
                      jjstateSet[jjnewStateCnt++] = 41;
 1694  7
                   break;
 1695   
                case 43:
 1696  7
                   if (curChar == 68)
 1697  7
                      jjstateSet[jjnewStateCnt++] = 42;
 1698  7
                   break;
 1699   
                case 46:
 1700  2936
                   jjAddStates(67, 69);
 1701  2936
                   break;
 1702  15178
                default : break;
 1703   
             }
 1704  22755
          } while(i != startsAt);
 1705   
       }
 1706   
       else
 1707   
       {
 1708  0
          int hiByte = (int)(curChar >> 8);
 1709  0
          int i1 = hiByte >> 6;
 1710  0
          long l1 = 1L << (hiByte & 077);
 1711  0
          int i2 = (curChar & 0xff) >> 6;
 1712  0
          long l2 = 1L << (curChar & 077);
 1713  0
          MatchLoop: do
 1714   
          {
 1715  0
             switch(jjstateSet[--i])
 1716   
             {
 1717   
                case 60:
 1718   
                case 54:
 1719   
                case 56:
 1720  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1721  0
                      jjCheckNAddStates(50, 52);
 1722  0
                   break;
 1723   
                case 59:
 1724  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1725  0
                      jjCheckNAddStates(50, 52);
 1726  0
                   break;
 1727   
                case 4:
 1728  0
                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
 1729  0
                      break;
 1730  0
                   if (kind > 3)
 1731  0
                      kind = 3;
 1732  0
                   jjCheckNAddTwoStates(5, 6);
 1733  0
                   break;
 1734   
                case 5:
 1735  0
                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
 1736  0
                      break;
 1737  0
                   if (kind > 3)
 1738  0
                      kind = 3;
 1739  0
                   jjCheckNAddTwoStates(5, 6);
 1740  0
                   break;
 1741   
                case 10:
 1742  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1743  0
                      jjCheckNAddTwoStates(10, 11);
 1744  0
                   break;
 1745   
                case 13:
 1746  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1747  0
                      jjCheckNAddTwoStates(13, 14);
 1748  0
                   break;
 1749   
                case 23:
 1750  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1751  0
                      jjAddStates(70, 71);
 1752  0
                   break;
 1753   
                case 27:
 1754  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1755  0
                      jjCheckNAddTwoStates(27, 11);
 1756  0
                   break;
 1757   
                case 29:
 1758  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1759  0
                      jjCheckNAddTwoStates(29, 14);
 1760  0
                   break;
 1761   
                case 31:
 1762  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1763  0
                      jjAddStates(72, 73);
 1764  0
                   break;
 1765   
                case 46:
 1766  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1767  0
                      jjAddStates(67, 69);
 1768  0
                   break;
 1769  0
                default : break;
 1770   
             }
 1771  0
          } while(i != startsAt);
 1772   
       }
 1773  16202
       if (kind != 0x7fffffff)
 1774   
       {
 1775  1758
          jjmatchedKind = kind;
 1776  1758
          jjmatchedPos = curPos;
 1777  1758
          kind = 0x7fffffff;
 1778   
       }
 1779  16202
       ++curPos;
 1780  ?
       if ((i = jjnewStateCnt) == (startsAt = 59 - (jjnewStateCnt = startsAt)))
 1781  1427
          return curPos;
 1782  14775
       try { curChar = input_stream.readChar(); }
 1783  0
       catch(java.io.IOException e) { return curPos; }
 1784   
    }
 1785   
 }
 1786  0
 private final int jjStopStringLiteralDfa_8(int pos, long active0)
 1787   
 {
 1788  0
    switch (pos)
 1789   
    {
 1790   
       default :
 1791  0
          return -1;
 1792   
    }
 1793   
 }
 1794  0
 private final int jjStartNfa_8(int pos, long active0)
 1795   
 {
 1796  0
    return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0), pos + 1);
 1797   
 }
 1798  0
 private final int jjStartNfaWithStates_8(int pos, int kind, int state)
 1799   
 {
 1800  0
    jjmatchedKind = kind;
 1801  0
    jjmatchedPos = pos;
 1802  0
    try { curChar = input_stream.readChar(); }
 1803  0
    catch(java.io.IOException e) { return pos + 1; }
 1804  0
    return jjMoveNfa_8(state, pos + 1);
 1805   
 }
 1806  0
 private final int jjMoveStringLiteralDfa0_8()
 1807   
 {
 1808  0
    switch(curChar)
 1809   
    {
 1810   
       case 39:
 1811  0
          return jjStopAtPos(0, 14);
 1812   
       default :
 1813  0
          return jjMoveNfa_8(1, 0);
 1814   
    }
 1815   
 }
 1816  0
 private final int jjMoveNfa_8(int startState, int curPos)
 1817   
 {
 1818  0
    int[] nextStates;
 1819  0
    int startsAt = 0;
 1820  0
    jjnewStateCnt = 13;
 1821  0
    int i = 1;
 1822  0
    jjstateSet[0] = startState;
 1823  0
    int j, kind = 0x7fffffff;
 1824  0
    for (;;)
 1825   
    {
 1826  0
       if (++jjround == 0x7fffffff)
 1827  0
          ReInitRounds();
 1828  0
       if (curChar < 64)
 1829   
       {
 1830  0
          long l = 1L << curChar;
 1831  0
          MatchLoop: do
 1832   
          {
 1833  0
             switch(jjstateSet[--i])
 1834   
             {
 1835   
                case 1:
 1836  0
                   if ((0xefffff3fffffffffL & l) != 0L)
 1837   
                   {
 1838  0
                      if (kind > 13)
 1839  0
                         kind = 13;
 1840  0
                      jjCheckNAdd(0);
 1841   
                   }
 1842  0
                   else if (curChar == 38)
 1843  0
                      jjAddStates(74, 75);
 1844  0
                   if (curChar == 38)
 1845  0
                      jjstateSet[jjnewStateCnt++] = 2;
 1846  0
                   break;
 1847   
                case 0:
 1848  0
                   if ((0xefffff3fffffffffL & l) == 0L)
 1849  0
                      break;
 1850  0
                   if (kind > 13)
 1851  0
                      kind = 13;
 1852  0
                   jjCheckNAdd(0);
 1853  0
                   break;
 1854   
                case 2:
 1855  0
                   if (curChar == 58)
 1856  0
                      jjCheckNAddTwoStates(3, 4);
 1857  0
                   break;
 1858   
                case 3:
 1859  0
                   if ((0x7ff600000000000L & l) != 0L)
 1860  0
                      jjCheckNAddTwoStates(3, 4);
 1861  0
                   break;
 1862   
                case 4:
 1863  0
                   if (curChar == 59 && kind > 15)
 1864  0
                      kind = 15;
 1865  0
                   break;
 1866   
                case 5:
 1867  0
                   if (curChar == 38)
 1868  0
                      jjAddStates(74, 75);
 1869  0
                   break;
 1870   
                case 6:
 1871  0
                   if (curChar == 35)
 1872  0
                      jjCheckNAdd(7);
 1873  0
                   break;
 1874   
                case 7:
 1875  0
                   if ((0x3ff000000000000L & l) != 0L)
 1876  0
                      jjCheckNAddTwoStates(7, 8);
 1877  0
                   break;
 1878   
                case 8:
 1879  0
                   if (curChar == 59 && kind > 16)
 1880  0
                      kind = 16;
 1881  0
                   break;
 1882   
                case 10:
 1883  0
                   if ((0x3ff000000000000L & l) != 0L)
 1884  0
                      jjAddStates(76, 77);
 1885  0
                   break;
 1886   
                case 11:
 1887  0
                   if (curChar == 59 && kind > 17)
 1888  0
                      kind = 17;
 1889  0
                   break;
 1890   
                case 12:
 1891  0
                   if (curChar == 35)
 1892  0
                      jjstateSet[jjnewStateCnt++] = 9;
 1893  0
                   break;
 1894  0
                default : break;
 1895   
             }
 1896  0
          } while(i != startsAt);
 1897   
       }
 1898  0
       else if (curChar < 128)
 1899   
       {
 1900  0
          long l = 1L << (curChar & 077);
 1901  0
          MatchLoop: do
 1902   
          {
 1903  0
             switch(jjstateSet[--i])
 1904   
             {
 1905   
                case 1:
 1906   
                case 0:
 1907  0
                   if (kind > 13)
 1908  0
                      kind = 13;
 1909  0
                   jjCheckNAdd(0);
 1910  0
                   break;
 1911   
                case 2:
 1912   
                case 3:
 1913  0
                   if ((0x7fffffe87fffffeL & l) != 0L)
 1914  0
                      jjCheckNAddTwoStates(3, 4);
 1915  0
                   break;
 1916   
                case 9:
 1917  0
                   if (curChar == 120)
 1918  0
                      jjCheckNAdd(10);
 1919  0
                   break;
 1920   
                case 10:
 1921  0
                   if ((0x7e0000007eL & l) != 0L)
 1922  0
                      jjCheckNAddTwoStates(10, 11);
 1923  0
                   break;
 1924  0
                default : break;
 1925   
             }
 1926  0
          } while(i != startsAt);
 1927   
       }
 1928   
       else
 1929   
       {
 1930  0
          int hiByte = (int)(curChar >> 8);
 1931  0
          int i1 = hiByte >> 6;
 1932  0
          long l1 = 1L << (hiByte & 077);
 1933  0
          int i2 = (curChar & 0xff) >> 6;
 1934  0
          long l2 = 1L << (curChar & 077);
 1935  0
          MatchLoop: do
 1936   
          {
 1937  0
             switch(jjstateSet[--i])
 1938   
             {
 1939   
                case 1:
 1940   
                case 0:
 1941  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 1942  0
                      break;
 1943  0
                   if (kind > 13)
 1944  0
                      kind = 13;
 1945  0
                   jjCheckNAdd(0);
 1946  0
                   break;
 1947   
                case 2:
 1948  0
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
 1949  0
                      jjCheckNAddTwoStates(3, 4);
 1950  0
                   break;
 1951   
                case 3:
 1952  0
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
 1953  0
                      jjCheckNAddTwoStates(3, 4);
 1954  0
                   break;
 1955  0
                default : break;
 1956   
             }
 1957  0
          } while(i != startsAt);
 1958   
       }
 1959  0
       if (kind != 0x7fffffff)
 1960   
       {
 1961  0
          jjmatchedKind = kind;
 1962  0
          jjmatchedPos = curPos;
 1963  0
          kind = 0x7fffffff;
 1964   
       }
 1965  0
       ++curPos;
 1966  0
       if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
 1967  0
          return curPos;
 1968  0
       try { curChar = input_stream.readChar(); }
 1969  0
       catch(java.io.IOException e) { return curPos; }
 1970   
    }
 1971   
 }
 1972  8323
 private final int jjStopStringLiteralDfa_5(int pos, long active0)
 1973   
 {
 1974  8323
    switch (pos)
 1975   
    {
 1976   
       case 0:
 1977  8209
          if ((active0 & 0x510L) != 0L)
 1978  8209
             return 13;
 1979  0
          return -1;
 1980   
       case 1:
 1981  114
          if ((active0 & 0x400L) != 0L)
 1982  114
             return 12;
 1983  0
          return -1;
 1984   
       default :
 1985  0
          return -1;
 1986   
    }
 1987   
 }
 1988  8323
 private final int jjStartNfa_5(int pos, long active0)
 1989   
 {
 1990  8323
    return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0), pos + 1);
 1991   
 }
 1992  0
 private final int jjStartNfaWithStates_5(int pos, int kind, int state)
 1993   
 {
 1994  0
    jjmatchedKind = kind;
 1995  0
    jjmatchedPos = pos;
 1996  0
    try { curChar = input_stream.readChar(); }
 1997  0
    catch(java.io.IOException e) { return pos + 1; }
 1998  0
    return jjMoveNfa_5(state, pos + 1);
 1999   
 }
 2000  25952
 private final int jjMoveStringLiteralDfa0_5()
 2001   
 {
 2002  25952
    switch(curChar)
 2003   
    {
 2004   
       case 60:
 2005  12905
          jjmatchedKind = 4;
 2006  12905
          return jjMoveStringLiteralDfa1_5(0x500L);
 2007   
       default :
 2008  13047
          return jjMoveNfa_5(1, 0);
 2009   
    }
 2010   
 }
 2011  12905
 private final int jjMoveStringLiteralDfa1_5(long active0)
 2012   
 {
 2013  12905
    try { curChar = input_stream.readChar(); }
 2014   
    catch(java.io.IOException e) {
 2015  0
       jjStopStringLiteralDfa_5(0, active0);
 2016  0
       return 1;
 2017   
    }
 2018  12905
    switch(curChar)
 2019   
    {
 2020   
       case 33:
 2021  122
          return jjMoveStringLiteralDfa2_5(active0, 0x400L);
 2022   
       case 47:
 2023  4574
          if ((active0 & 0x100L) != 0L)
 2024  4574
             return jjStopAtPos(1, 8);
 2025  0
          break;
 2026   
       default :
 2027  8209
          break;
 2028   
    }
 2029  8209
    return jjStartNfa_5(0, active0);
 2030   
 }
 2031  122
 private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
 2032   
 {
 2033  122
    if (((active0 &= old0)) == 0L)
 2034  0
       return jjStartNfa_5(0, old0); 
 2035  122
    try { curChar = input_stream.readChar(); }
 2036   
    catch(java.io.IOException e) {
 2037  0
       jjStopStringLiteralDfa_5(1, active0);
 2038  0
       return 2;
 2039   
    }
 2040  122
    switch(curChar)
 2041   
    {
 2042   
       case 91:
 2043  8
          return jjMoveStringLiteralDfa3_5(active0, 0x400L);
 2044   
       default :
 2045  114
          break;
 2046   
    }
 2047  114
    return jjStartNfa_5(1, active0);
 2048   
 }
 2049  8
 private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
 2050   
 {
 2051  8
    if (((active0 &= old0)) == 0L)
 2052  0
       return jjStartNfa_5(1, old0); 
 2053  8
    try { curChar = input_stream.readChar(); }
 2054   
    catch(java.io.IOException e) {
 2055  0
       jjStopStringLiteralDfa_5(2, active0);
 2056  0
       return 3;
 2057   
    }
 2058  8
    switch(curChar)
 2059   
    {
 2060   
       case 67:
 2061  8
          return jjMoveStringLiteralDfa4_5(active0, 0x400L);
 2062   
       default :
 2063  0
          break;
 2064   
    }
 2065  0
    return jjStartNfa_5(2, active0);
 2066   
 }
 2067  8
 private final int jjMoveStringLiteralDfa4_5(long old0, long active0)
 2068   
 {
 2069  8
    if (((active0 &= old0)) == 0L)
 2070  0
       return jjStartNfa_5(2, old0); 
 2071  8
    try { curChar = input_stream.readChar(); }
 2072   
    catch(java.io.IOException e) {
 2073  0
       jjStopStringLiteralDfa_5(3, active0);
 2074  0
       return 4;
 2075   
    }
 2076  8
    switch(curChar)
 2077   
    {
 2078   
       case 68:
 2079  8
          return jjMoveStringLiteralDfa5_5(active0, 0x400L);
 2080   
       default :
 2081  0
          break;
 2082   
    }
 2083  0
    return jjStartNfa_5(3, active0);
 2084   
 }
 2085  8
 private final int jjMoveStringLiteralDfa5_5(long old0, long active0)
 2086   
 {
 2087  8
    if (((active0 &= old0)) == 0L)
 2088  0
       return jjStartNfa_5(3, old0); 
 2089  8
    try { curChar = input_stream.readChar(); }
 2090   
    catch(java.io.IOException e) {
 2091  0
       jjStopStringLiteralDfa_5(4, active0);
 2092  0
       return 5;
 2093   
    }
 2094  8
    switch(curChar)
 2095   
    {
 2096   
       case 65:
 2097  8
          return jjMoveStringLiteralDfa6_5(active0, 0x400L);
 2098   
       default :
 2099  0
          break;
 2100   
    }
 2101  0
    return jjStartNfa_5(4, active0);
 2102   
 }
 2103  8
 private final int jjMoveStringLiteralDfa6_5(long old0, long active0)
 2104   
 {
 2105  8
    if (((active0 &= old0)) == 0L)
 2106  0
       return jjStartNfa_5(4, old0); 
 2107  8
    try { curChar = input_stream.readChar(); }
 2108   
    catch(java.io.IOException e) {
 2109  0
       jjStopStringLiteralDfa_5(5, active0);
 2110  0
       return 6;
 2111   
    }
 2112  8
    switch(curChar)
 2113   
    {
 2114   
       case 84:
 2115  8
          return jjMoveStringLiteralDfa7_5(active0, 0x400L);
 2116   
       default :
 2117  0
          break;
 2118   
    }
 2119  0
    return jjStartNfa_5(5, active0);
 2120   
 }
 2121  8
 private final int jjMoveStringLiteralDfa7_5(long old0, long active0)
 2122   
 {
 2123  8
    if (((active0 &= old0)) == 0L)
 2124  0
       return jjStartNfa_5(5, old0); 
 2125  8
    try { curChar = input_stream.readChar(); }
 2126   
    catch(java.io.IOException e) {
 2127  0
       jjStopStringLiteralDfa_5(6, active0);
 2128  0
       return 7;
 2129   
    }
 2130  8
    switch(curChar)
 2131   
    {
 2132   
       case 65:
 2133  8
          return jjMoveStringLiteralDfa8_5(active0, 0x400L);
 2134   
       default :
 2135  0
          break;
 2136   
    }
 2137  0
    return jjStartNfa_5(6, active0);
 2138   
 }
 2139  8
 private final int jjMoveStringLiteralDfa8_5(long old0, long active0)
 2140   
 {
 2141  8
    if (((active0 &= old0)) == 0L)
 2142  0
       return jjStartNfa_5(6, old0); 
 2143  8
    try { curChar = input_stream.readChar(); }
 2144   
    catch(java.io.IOException e) {
 2145  0
       jjStopStringLiteralDfa_5(7, active0);
 2146  0
       return 8;
 2147   
    }
 2148  8
    switch(curChar)
 2149   
    {
 2150   
       case 91:
 2151  8
          if ((active0 & 0x400L) != 0L)
 2152  8
             return jjStopAtPos(8, 10);
 2153  0
          break;
 2154   
       default :
 2155  0
          break;
 2156   
    }
 2157  0
    return jjStartNfa_5(7, active0);
 2158   
 }
 2159  21370
 private final int jjMoveNfa_5(int startState, int curPos)
 2160   
 {
 2161  21370
    int[] nextStates;
 2162  21370
    int startsAt = 0;
 2163  21370
    jjnewStateCnt = 28;
 2164  21370
    int i = 1;
 2165  21370
    jjstateSet[0] = startState;
 2166  21370
    int j, kind = 0x7fffffff;
 2167  21370
    for (;;)
 2168   
    {
 2169  133951
       if (++jjround == 0x7fffffff)
 2170  0
          ReInitRounds();
 2171  133951
       if (curChar < 64)
 2172   
       {
 2173  101051
          long l = 1L << curChar;
 2174  101051
          MatchLoop: do
 2175   
          {
 2176  105117
             switch(jjstateSet[--i])
 2177   
             {
 2178   
                case 1:
 2179  12811
                   if ((0xefffffbfffffffffL & l) != 0L)
 2180   
                   {
 2181  12765
                      if (kind > 9)
 2182  12765
                         kind = 9;
 2183  12765
                      jjCheckNAdd(0);
 2184   
                   }
 2185  46
                   else if (curChar == 38)
 2186  46
                      jjAddStates(78, 79);
 2187  0
                   else if (curChar == 60)
 2188  0
                      jjAddStates(80, 81);
 2189  12811
                   if (curChar == 38)
 2190  46
                      jjstateSet[jjnewStateCnt++] = 2;
 2191  12811
                   break;
 2192   
                case 13:
 2193  0
                   if (curChar == 33)
 2194  0
                      jjstateSet[jjnewStateCnt++] = 12;
 2195  0
                   else if (curChar == 63)
 2196  0
                      jjCheckNAddTwoStates(15, 16);
 2197  0
                   break;
 2198   
                case 0:
 2199  85726
                   if ((0xefffffbfffffffffL & l) == 0L)
 2200  12565
                      break;
 2201  73161
                   if (kind > 9)
 2202  73161
                      kind = 9;
 2203  73161
                   jjCheckNAdd(0);
 2204  73161
                   break;
 2205   
                case 2:
 2206  0
                   if (curChar == 58)
 2207  0
                      jjCheckNAddTwoStates(3, 4);
 2208  0
                   break;
 2209   
                case 3:
 2210  46
                   if ((0x7ff600000000000L & l) != 0L)
 2211  0
                      jjCheckNAddTwoStates(3, 4);
 2212  46
                   break;
 2213   
                case 4:
 2214  46
                   if (curChar == 59 && kind > 15)
 2215  46
                      kind = 15;
 2216  46
                   break;
 2217   
                case 5:
 2218  0
                   if (curChar == 60)
 2219  0
                      jjAddStates(80, 81);
 2220  0
                   break;
 2221   
                case 6:
 2222  114
                   if (curChar == 45)
 2223  114
                      jjCheckNAddTwoStates(7, 8);
 2224  114
                   break;
 2225   
                case 7:
 2226  2126
                   if ((0xffffdfffffffffffL & l) != 0L)
 2227  1893
                      jjCheckNAddStates(82, 84);
 2228  2126
                   break;
 2229   
                case 8:
 2230  2008
                   if (curChar == 45)
 2231  119
                      jjCheckNAdd(7);
 2232  2008
                   break;
 2233   
                case 9:
 2234  114
                   if (curChar == 62 && kind > 6)
 2235  114
                      kind = 6;
 2236  114
                   break;
 2237   
                case 10:
 2238  118
                   if (curChar == 45)
 2239  114
                      jjstateSet[jjnewStateCnt++] = 9;
 2240  118
                   break;
 2241   
                case 11:
 2242  1894
                   if (curChar == 45)
 2243  119
                      jjstateSet[jjnewStateCnt++] = 10;
 2244  1894
                   break;
 2245   
                case 12:
 2246  114
                   if (curChar == 45)
 2247  114
                      jjstateSet[jjnewStateCnt++] = 6;
 2248  114
                   break;
 2249   
                case 14:
 2250  0
                   if (curChar == 63)
 2251  0
                      jjCheckNAddTwoStates(15, 16);
 2252  0
                   break;
 2253   
                case 15:
 2254  0
                   if ((0x7fffffffffffffffL & l) != 0L)
 2255  0
                      jjCheckNAddStates(85, 87);
 2256  0
                   break;
 2257   
                case 16:
 2258  0
                   if (curChar == 63)
 2259  0
                      jjstateSet[jjnewStateCnt++] = 17;
 2260  0
                   break;
 2261   
                case 17:
 2262  0
                   if ((0xbfffffffffffffffL & l) != 0L)
 2263  0
                      jjCheckNAddStates(85, 87);
 2264  0
                   break;
 2265   
                case 18:
 2266  0
                   if (curChar == 62 && kind > 7)
 2267  0
                      kind = 7;
 2268  0
                   break;
 2269   
                case 19:
 2270  0
                   if (curChar == 63)
 2271  0
                      jjstateSet[jjnewStateCnt++] = 18;
 2272  0
                   break;
 2273   
                case 20:
 2274  0
                   if (curChar == 38)
 2275  0
                      jjAddStates(78, 79);
 2276  0
                   break;
 2277   
                case 21:
 2278  0
                   if (curChar == 35)
 2279  0
                      jjCheckNAdd(22);
 2280  0
                   break;
 2281   
                case 22:
 2282  0
                   if ((0x3ff000000000000L & l) != 0L)
 2283  0
                      jjCheckNAddTwoStates(22, 23);
 2284  0
                   break;
 2285   
                case 23:
 2286  0
                   if (curChar == 59 && kind > 16)
 2287  0
                      kind = 16;
 2288  0
                   break;
 2289   
                case 25:
 2290  0
                   if ((0x3ff000000000000L & l) != 0L)
 2291  0
                      jjAddStates(88, 89);
 2292  0
                   break;
 2293   
                case 26:
 2294  0
                   if (curChar == 59 && kind > 17)
 2295  0
                      kind = 17;
 2296  0
                   break;
 2297   
                case 27:
 2298  0
                   if (curChar == 35)
 2299  0
                      jjstateSet[jjnewStateCnt++] = 24;
 2300  0
                   break;
 2301  0
                default : break;
 2302   
             }
 2303  105117
          } while(i != startsAt);
 2304   
       }
 2305  32900
       else if (curChar < 128)
 2306   
       {
 2307  32900
          long l = 1L << (curChar & 077);
 2308  32900
          MatchLoop: do
 2309   
          {
 2310  39117
             switch(jjstateSet[--i])
 2311   
             {
 2312   
                case 1:
 2313   
                case 0:
 2314  21556
                   if (kind > 9)
 2315  21556
                      kind = 9;
 2316  21556
                   jjCheckNAdd(0);
 2317  21556
                   break;
 2318   
                case 2:
 2319   
                case 3:
 2320  98
                   if ((0x7fffffe87fffffeL & l) != 0L)
 2321  98
                      jjCheckNAddTwoStates(3, 4);
 2322  98
                   break;
 2323   
                case 7:
 2324  3037
                   jjAddStates(82, 84);
 2325  3037
                   break;
 2326   
                case 15:
 2327   
                case 17:
 2328  0
                   jjCheckNAddStates(85, 87);
 2329  0
                   break;
 2330   
                case 24:
 2331  0
                   if (curChar == 120)
 2332  0
                      jjCheckNAdd(25);
 2333  0
                   break;
 2334   
                case 25:
 2335  0
                   if ((0x7e0000007eL & l) != 0L)
 2336  0
                      jjCheckNAddTwoStates(25, 26);
 2337  0
                   break;
 2338  14426
                default : break;
 2339   
             }
 2340  39117
          } while(i != startsAt);
 2341   
       }
 2342   
       else
 2343   
       {
 2344  0
          int hiByte = (int)(curChar >> 8);
 2345  0
          int i1 = hiByte >> 6;
 2346  0
          long l1 = 1L << (hiByte & 077);
 2347  0
          int i2 = (curChar & 0xff) >> 6;
 2348  0
          long l2 = 1L << (curChar & 077);
 2349  0
          MatchLoop: do
 2350   
          {
 2351  0
             switch(jjstateSet[--i])
 2352   
             {
 2353   
                case 1:
 2354   
                case 0:
 2355  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 2356  0
                      break;
 2357  0
                   if (kind > 9)
 2358  0
                      kind = 9;
 2359  0
                   jjCheckNAdd(0);
 2360  0
                   break;
 2361   
                case 2:
 2362  0
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
 2363  0
                      jjCheckNAddTwoStates(3, 4);
 2364  0
                   break;
 2365   
                case 3:
 2366  0
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
 2367  0
                      jjCheckNAddTwoStates(3, 4);
 2368  0
                   break;
 2369   
                case 7:
 2370  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 2371  0
                      jjAddStates(82, 84);
 2372  0
                   break;
 2373   
                case 15:
 2374   
                case 17:
 2375  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 2376  0
                      jjCheckNAddStates(85, 87);
 2377  0
                   break;
 2378  0
                default : break;
 2379   
             }
 2380  0
          } while(i != startsAt);
 2381   
       }
 2382  133951
       if (kind != 0x7fffffff)
 2383   
       {
 2384  107642
          jjmatchedKind = kind;
 2385  107642
          jjmatchedPos = curPos;
 2386  107642
          kind = 0x7fffffff;
 2387   
       }
 2388  133951
       ++curPos;
 2389  ?
       if ((i = jjnewStateCnt) == (startsAt = 28 - (jjnewStateCnt = startsAt)))
 2390  20934
          return curPos;
 2391  113017
       try { curChar = input_stream.readChar(); }
 2392  436
       catch(java.io.IOException e) { return curPos; }
 2393   
    }
 2394   
 }
 2395  0
 private final int jjMoveStringLiteralDfa0_10()
 2396   
 {
 2397  0
    return 1;
 2398   
 }
 2399  0
 private final int jjStopStringLiteralDfa_3(int pos, long active0)
 2400   
 {
 2401  0
    switch (pos)
 2402   
    {
 2403   
       default :
 2404  0
          return -1;
 2405   
    }
 2406   
 }
 2407  0
 private final int jjStartNfa_3(int pos, long active0)
 2408   
 {
 2409  0
    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
 2410   
 }
 2411  0
 private final int jjStartNfaWithStates_3(int pos, int kind, int state)
 2412   
 {
 2413  0
    jjmatchedKind = kind;
 2414  0
    jjmatchedPos = pos;
 2415  0
    try { curChar = input_stream.readChar(); }
 2416  0
    catch(java.io.IOException e) { return pos + 1; }
 2417  0
    return jjMoveNfa_3(state, pos + 1);
 2418   
 }
 2419  0
 private final int jjMoveStringLiteralDfa0_3()
 2420   
 {
 2421  0
    switch(curChar)
 2422   
    {
 2423   
       case 61:
 2424  0
          return jjStopAtPos(0, 48);
 2425   
       case 63:
 2426  0
          return jjMoveStringLiteralDfa1_3(0x100000000000L);
 2427   
       case 101:
 2428  0
          return jjMoveStringLiteralDfa1_3(0x400000000000L);
 2429   
       case 115:
 2430  0
          return jjMoveStringLiteralDfa1_3(0x800000000000L);
 2431   
       case 118:
 2432  0
          return jjMoveStringLiteralDfa1_3(0x200000000000L);
 2433   
       default :
 2434  0
          return jjMoveNfa_3(1, 0);
 2435   
    }
 2436   
 }
 2437  0
 private final int jjMoveStringLiteralDfa1_3(long active0)
 2438   
 {
 2439  0
    try { curChar = input_stream.readChar(); }
 2440   
    catch(java.io.IOException e) {
 2441  0
       jjStopStringLiteralDfa_3(0, active0);
 2442  0
       return 1;
 2443   
    }
 2444  0
    switch(curChar)
 2445   
    {
 2446   
       case 62:
 2447  0
          if ((active0 & 0x100000000000L) != 0L)
 2448  0
             return jjStopAtPos(1, 44);
 2449  0
          break;
 2450   
       case 101:
 2451  0
          return jjMoveStringLiteralDfa2_3(active0, 0x200000000000L);
 2452   
       case 110:
 2453  0
          return jjMoveStringLiteralDfa2_3(active0, 0x400000000000L);
 2454   
       case 116:
 2455  0
          return jjMoveStringLiteralDfa2_3(active0, 0x800000000000L);
 2456   
       default :
 2457  0
          break;
 2458   
    }
 2459  0
    return jjStartNfa_3(0, active0);
 2460   
 }
 2461  0
 private final int jjMoveStringLiteralDfa2_3(long old0, long active0)
 2462   
 {
 2463  0
    if (((active0 &= old0)) == 0L)
 2464  0
       return jjStartNfa_3(0, old0); 
 2465  0
    try { curChar = input_stream.readChar(); }
 2466   
    catch(java.io.IOException e) {
 2467  0
       jjStopStringLiteralDfa_3(1, active0);
 2468  0
       return 2;
 2469   
    }
 2470  0
    switch(curChar)
 2471   
    {
 2472   
       case 97:
 2473  0
          return jjMoveStringLiteralDfa3_3(active0, 0x800000000000L);
 2474   
       case 99:
 2475  0
          return jjMoveStringLiteralDfa3_3(active0, 0x400000000000L);
 2476   
       case 114:
 2477  0
          return jjMoveStringLiteralDfa3_3(active0, 0x200000000000L);
 2478   
       default :
 2479  0
          break;
 2480   
    }
 2481  0
    return jjStartNfa_3(1, active0);
 2482   
 }
 2483  0
 private final int jjMoveStringLiteralDfa3_3(long old0, long active0)
 2484   
 {
 2485  0
    if (((active0 &= old0)) == 0L)
 2486  0
       return jjStartNfa_3(1, old0); 
 2487  0
    try { curChar = input_stream.readChar(); }
 2488   
    catch(java.io.IOException e) {
 2489  0
       jjStopStringLiteralDfa_3(2, active0);
 2490  0
       return 3;
 2491   
    }
 2492  0
    switch(curChar)
 2493   
    {
 2494   
       case 110:
 2495  0
          return jjMoveStringLiteralDfa4_3(active0, 0x800000000000L);
 2496   
       case 111:
 2497  0
          return jjMoveStringLiteralDfa4_3(active0, 0x400000000000L);
 2498   
       case 115:
 2499  0
          return jjMoveStringLiteralDfa4_3(active0, 0x200000000000L);
 2500   
       default :
 2501  0
          break;
 2502   
    }
 2503  0
    return jjStartNfa_3(2, active0);
 2504   
 }
 2505  0
 private final int jjMoveStringLiteralDfa4_3(long old0, long active0)
 2506   
 {
 2507  0
    if (((active0 &= old0)) == 0L)
 2508  0
       return jjStartNfa_3(2, old0); 
 2509  0
    try { curChar = input_stream.readChar(); }
 2510   
    catch(java.io.IOException e) {
 2511  0
       jjStopStringLiteralDfa_3(3, active0);
 2512  0
       return 4;
 2513   
    }
 2514  0
    switch(curChar)
 2515   
    {
 2516   
       case 100:
 2517  0
          return jjMoveStringLiteralDfa5_3(active0, 0xc00000000000L);
 2518   
       case 105:
 2519  0
          return jjMoveStringLiteralDfa5_3(active0, 0x200000000000L);
 2520   
       default :
 2521  0
          break;
 2522   
    }
 2523  0
    return jjStartNfa_3(3, active0);
 2524   
 }
 2525  0
 private final int jjMoveStringLiteralDfa5_3(long old0, long active0)
 2526   
 {
 2527  0
    if (((active0 &= old0)) == 0L)
 2528  0
       return jjStartNfa_3(3, old0); 
 2529  0
    try { curChar = input_stream.readChar(); }
 2530   
    catch(java.io.IOException e) {
 2531  0
       jjStopStringLiteralDfa_3(4, active0);
 2532  0
       return 5;
 2533   
    }
 2534  0
    switch(curChar)
 2535   
    {
 2536   
       case 97:
 2537  0
          return jjMoveStringLiteralDfa6_3(active0, 0x800000000000L);
 2538   
       case 105:
 2539  0
          return jjMoveStringLiteralDfa6_3(active0, 0x400000000000L);
 2540   
       case 111:
 2541  0
          return jjMoveStringLiteralDfa6_3(active0, 0x200000000000L);
 2542   
       default :
 2543  0
          break;
 2544   
    }
 2545  0
    return jjStartNfa_3(4, active0);
 2546   
 }
 2547  0
 private final int jjMoveStringLiteralDfa6_3(long old0, long active0)
 2548   
 {
 2549  0
    if (((active0 &= old0)) == 0L)
 2550  0
       return jjStartNfa_3(4, old0); 
 2551  0
    try { curChar = input_stream.readChar(); }
 2552   
    catch(java.io.IOException e) {
 2553  0
       jjStopStringLiteralDfa_3(5, active0);
 2554  0
       return 6;
 2555   
    }
 2556  0
    switch(curChar)
 2557   
    {
 2558   
       case 108:
 2559  0
          return jjMoveStringLiteralDfa7_3(active0, 0x800000000000L);
 2560   
       case 110:
 2561  0
          if ((active0 & 0x200000000000L) != 0L)
 2562  0
             return jjStopAtPos(6, 45);
 2563  0
          return jjMoveStringLiteralDfa7_3(active0, 0x400000000000L);
 2564   
       default :
 2565  0
          break;
 2566   
    }
 2567  0
    return jjStartNfa_3(5, active0);
 2568   
 }
 2569  0
 private final int jjMoveStringLiteralDfa7_3(long old0, long active0)
 2570   
 {
 2571  0
    if (((active0 &= old0)) == 0L)
 2572  0
       return jjStartNfa_3(5, old0); 
 2573  0
    try { curChar = input_stream.readChar(); }
 2574   
    catch(java.io.IOException e) {
 2575  0
       jjStopStringLiteralDfa_3(6, active0);
 2576  0
       return 7;
 2577   
    }
 2578  0
    switch(curChar)
 2579   
    {
 2580   
       case 103:
 2581  0
          if ((active0 & 0x400000000000L) != 0L)
 2582  0
             return jjStopAtPos(7, 46);
 2583  0
          break;
 2584   
       case 111:
 2585  0
          return jjMoveStringLiteralDfa8_3(active0, 0x800000000000L);
 2586   
       default :
 2587  0
          break;
 2588   
    }
 2589  0
    return jjStartNfa_3(6, active0);
 2590   
 }
 2591  0
 private final int jjMoveStringLiteralDfa8_3(long old0, long active0)
 2592   
 {
 2593  0
    if (((active0 &= old0)) == 0L)
 2594  0
       return jjStartNfa_3(6, old0); 
 2595  0
    try { curChar = input_stream.readChar(); }
 2596   
    catch(java.io.IOException e) {
 2597  0
       jjStopStringLiteralDfa_3(7, active0);
 2598  0
       return 8;
 2599   
    }
 2600  0
    switch(curChar)
 2601   
    {
 2602   
       case 110:
 2603  0
          return jjMoveStringLiteralDfa9_3(active0, 0x800000000000L);
 2604   
       default :
 2605  0
          break;
 2606   
    }
 2607  0
    return jjStartNfa_3(7, active0);
 2608   
 }
 2609  0
 private final int jjMoveStringLiteralDfa9_3(long old0, long active0)
 2610   
 {
 2611  0
    if (((active0 &= old0)) == 0L)
 2612  0
       return jjStartNfa_3(7, old0); 
 2613  0
    try { curChar = input_stream.readChar(); }
 2614   
    catch(java.io.IOException e) {
 2615  0
       jjStopStringLiteralDfa_3(8, active0);
 2616  0
       return 9;
 2617   
    }
 2618  0
    switch(curChar)
 2619   
    {
 2620   
       case 101:
 2621  0
          if ((active0 & 0x800000000000L) != 0L)
 2622  0
             return jjStopAtPos(9, 47);
 2623  0
          break;
 2624   
       default :
 2625  0
          break;
 2626   
    }
 2627  0
    return jjStartNfa_3(8, active0);
 2628   
 }
 2629  0
 private final int jjMoveNfa_3(int startState, int curPos)
 2630   
 {
 2631  0
    int[] nextStates;
 2632  0
    int startsAt = 0;
 2633  0
    jjnewStateCnt = 7;
 2634  0
    int i = 1;
 2635  0
    jjstateSet[0] = startState;
 2636  0
    int j, kind = 0x7fffffff;
 2637  0
    for (;;)
 2638   
    {
 2639  0
       if (++jjround == 0x7fffffff)
 2640  0
          ReInitRounds();
 2641  0
       if (curChar < 64)
 2642   
       {
 2643  0
          long l = 1L << curChar;
 2644  0
          MatchLoop: do
 2645   
          {
 2646  0
             switch(jjstateSet[--i])
 2647   
             {
 2648   
                case 1:
 2649  0
                   if ((0x100002600L & l) != 0L)
 2650   
                   {
 2651  0
                      if (kind > 1)
 2652  0
                         kind = 1;
 2653  0
                      jjCheckNAdd(0);
 2654   
                   }
 2655  0
                   else if (curChar == 34)
 2656  0
                      jjCheckNAddTwoStates(5, 6);
 2657  0
                   else if (curChar == 39)
 2658  0
                      jjCheckNAddTwoStates(2, 3);
 2659  0
                   break;
 2660   
                case 0:
 2661  0
                   if ((0x100002600L & l) == 0L)
 2662  0
                      break;
 2663  0
                   if (kind > 1)
 2664  0
                      kind = 1;
 2665  0
                   jjCheckNAdd(0);
 2666  0
                   break;
 2667   
                case 2:
 2668  0
                   if ((0xffffff7fffffffffL & l) != 0L)
 2669  0
                      jjCheckNAddTwoStates(2, 3);
 2670  0
                   break;
 2671   
                case 3:
 2672  0
                   if (curChar == 39 && kind > 49)
 2673  0
                      kind = 49;
 2674  0
                   break;
 2675   
                case 4:
 2676  0
                   if (curChar == 34)
 2677  0
                      jjCheckNAddTwoStates(5, 6);
 2678  0
                   break;
 2679   
                case 5:
 2680  0
                   if ((0xfffffffbffffffffL & l) != 0L)
 2681  0
                      jjCheckNAddTwoStates(5, 6);
 2682  0
                   break;
 2683   
                case 6:
 2684  0
                   if (curChar == 34 && kind > 49)
 2685  0
                      kind = 49;
 2686  0
                   break;
 2687  0
                default : break;
 2688   
             }
 2689  0
          } while(i != startsAt);
 2690   
       }
 2691  0
       else if (curChar < 128)
 2692   
       {
 2693  0
          long l = 1L << (curChar & 077);
 2694  0
          MatchLoop: do
 2695   
          {
 2696  0
             switch(jjstateSet[--i])
 2697   
             {
 2698   
                case 2:
 2699  0
                   jjAddStates(90, 91);
 2700  0
                   break;
 2701   
                case 5:
 2702  0
                   jjAddStates(92, 93);
 2703  0
                   break;
 2704  0
                default : break;
 2705   
             }
 2706  0
          } while(i != startsAt);
 2707   
       }
 2708   
       else
 2709   
       {
 2710  0
          int hiByte = (int)(curChar >> 8);
 2711  0
          int i1 = hiByte >> 6;
 2712  0
          long l1 = 1L << (hiByte & 077);
 2713  0
          int i2 = (curChar & 0xff) >> 6;
 2714  0
          long l2 = 1L << (curChar & 077);
 2715  0
          MatchLoop: do
 2716   
          {
 2717  0
             switch(jjstateSet[--i])
 2718   
             {
 2719   
                case 2:
 2720  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 2721  0
                      jjAddStates(90, 91);
 2722  0
                   break;
 2723   
                case 5:
 2724  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 2725  0
                      jjAddStates(92, 93);
 2726  0
                   break;
 2727  0
                default : break;
 2728   
             }
 2729  0
          } while(i != startsAt);
 2730   
       }
 2731  0
       if (kind != 0x7fffffff)
 2732   
       {
 2733  0
          jjmatchedKind = kind;
 2734  0
          jjmatchedPos = curPos;
 2735  0
          kind = 0x7fffffff;
 2736   
       }
 2737  0
       ++curPos;
 2738  0
       if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
 2739  0
          return curPos;
 2740  0
       try { curChar = input_stream.readChar(); }
 2741  0
       catch(java.io.IOException e) { return curPos; }
 2742   
    }
 2743   
 }
 2744  0
 private final int jjStopStringLiteralDfa_7(int pos, long active0)
 2745   
 {
 2746  0
    switch (pos)
 2747   
    {
 2748   
       default :
 2749  0
          return -1;
 2750   
    }
 2751   
 }
 2752  0
 private final int jjStartNfa_7(int pos, long active0)
 2753   
 {
 2754  0
    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0), pos + 1);
 2755   
 }
 2756  0
 private final int jjStartNfaWithStates_7(int pos, int kind, int state)
 2757   
 {
 2758  0
    jjmatchedKind = kind;
 2759  0
    jjmatchedPos = pos;
 2760  0
    try { curChar = input_stream.readChar(); }
 2761  0
    catch(java.io.IOException e) { return pos + 1; }
 2762  0
    return jjMoveNfa_7(state, pos + 1);
 2763   
 }
 2764  20504
 private final int jjMoveStringLiteralDfa0_7()
 2765   
 {
 2766  20504
    switch(curChar)
 2767   
    {
 2768   
       case 34:
 2769  10255
          return jjStopAtPos(0, 12);
 2770   
       default :
 2771  10249
          return jjMoveNfa_7(1, 0);
 2772   
    }
 2773   
 }
 2774  10249
 private final int jjMoveNfa_7(int startState, int curPos)
 2775   
 {
 2776  10249
    int[] nextStates;
 2777  10249
    int startsAt = 0;
 2778  10249
    jjnewStateCnt = 13;
 2779  10249
    int i = 1;
 2780  10249
    jjstateSet[0] = startState;
 2781  10249
    int j, kind = 0x7fffffff;
 2782  10249
    for (;;)
 2783   
    {
 2784  121231
       if (++jjround == 0x7fffffff)
 2785  0
          ReInitRounds();
 2786  121231
       if (curChar < 64)
 2787   
       {
 2788  25778
          long l = 1L << curChar;
 2789  25778
          MatchLoop: do
 2790   
          {
 2791  25782
             switch(jjstateSet[--i])
 2792   
             {
 2793   
                case 1:
 2794  952
                   if ((0xefffffbbffffffffL & l) != 0L)
 2795   
                   {
 2796  948
                      if (kind > 11)
 2797  948
                         kind = 11;
 2798  948
                      jjCheckNAdd(0);
 2799   
                   }
 2800  4
                   else if (curChar == 38)
 2801  4
                      jjAddStates(74, 75);
 2802  952
                   if (curChar == 38)
 2803  4
                      jjstateSet[jjnewStateCnt++] = 2;
 2804  952
                   break;
 2805   
                case 0:
 2806  24822
                   if ((0xefffffbbffffffffL & l) == 0L)
 2807  10245
                      break;
 2808  14577
                   if (kind > 11)
 2809  14577
                      kind = 11;
 2810  14577
                   jjCheckNAdd(0);
 2811  14577
                   break;
 2812   
                case 2:
 2813  0
                   if (curChar == 58)
 2814  0
                      jjCheckNAddTwoStates(3, 4);
 2815  0
                   break;
 2816   
                case 3:
 2817  4
                   if ((0x7ff600000000000L & l) != 0L)
 2818  0
                      jjCheckNAddTwoStates(3, 4);
 2819  4
                   break;
 2820   
                case 4:
 2821  4
                   if (curChar == 59 && kind > 15)
 2822  4
                      kind = 15;
 2823  4
                   break;
 2824   
                case 5:
 2825  0
                   if (curChar == 38)
 2826  0
                      jjAddStates(74, 75);
 2827  0
                   break;
 2828   
                case 6:
 2829  0
                   if (curChar == 35)
 2830  0
                      jjCheckNAdd(7);
 2831  0
                   break;
 2832   
                case 7:
 2833  0
                   if ((0x3ff000000000000L & l) != 0L)
 2834  0
                      jjCheckNAddTwoStates(7, 8);
 2835  0
                   break;
 2836   
                case 8:
 2837  0
                   if (curChar == 59 && kind > 16)
 2838  0
                      kind = 16;
 2839  0
                   break;
 2840   
                case 10:
 2841  0
                   if ((0x3ff000000000000L & l) != 0L)
 2842  0
                      jjAddStates(76, 77);
 2843  0
                   break;
 2844   
                case 11:
 2845  0
                   if (curChar == 59 && kind > 17)
 2846  0
                      kind = 17;
 2847  0
                   break;
 2848   
                case 12:
 2849  0
                   if (curChar == 35)
 2850  0
                      jjstateSet[jjnewStateCnt++] = 9;
 2851  0
                   break;
 2852  0
                default : break;
 2853   
             }
 2854  25782
          } while(i != startsAt);
 2855   
       }
 2856  95453
       else if (curChar < 128)
 2857   
       {
 2858  95451
          long l = 1L << (curChar & 077);
 2859  95451
          MatchLoop: do
 2860   
          {
 2861  95463
             switch(jjstateSet[--i])
 2862   
             {
 2863   
                case 1:
 2864   
                case 0:
 2865  95443
                   if (kind > 11)
 2866  95443
                      kind = 11;
 2867  95443
                   jjCheckNAdd(0);
 2868  95443
                   break;
 2869   
                case 2:
 2870   
                case 3:
 2871  8
                   if ((0x7fffffe87fffffeL & l) != 0L)
 2872  8
                      jjCheckNAddTwoStates(3, 4);
 2873  8
                   break;
 2874   
                case 9:
 2875  0
                   if (curChar == 120)
 2876  0
                      jjCheckNAdd(10);
 2877  0
                   break;
 2878   
                case 10:
 2879  0
                   if ((0x7e0000007eL & l) != 0L)
 2880  0
                      jjCheckNAddTwoStates(10, 11);
 2881  0
                   break;
 2882  12
                default : break;
 2883   
             }
 2884  95463
          } while(i != startsAt);
 2885   
       }
 2886   
       else
 2887   
       {
 2888  2
          int hiByte = (int)(curChar >> 8);
 2889  2
          int i1 = hiByte >> 6;
 2890  2
          long l1 = 1L << (hiByte & 077);
 2891  2
          int i2 = (curChar & 0xff) >> 6;
 2892  2
          long l2 = 1L << (curChar & 077);
 2893  2
          MatchLoop: do
 2894   
          {
 2895  2
             switch(jjstateSet[--i])
 2896   
             {
 2897   
                case 1:
 2898   
                case 0:
 2899  2
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 2900  0
                      break;
 2901  2
                   if (kind > 11)
 2902  2
                      kind = 11;
 2903  2
                   jjCheckNAdd(0);
 2904  2
                   break;
 2905   
                case 2:
 2906  0
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
 2907  0
                      jjCheckNAddTwoStates(3, 4);
 2908  0
                   break;
 2909   
                case 3:
 2910  0
                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
 2911  0
                      jjCheckNAddTwoStates(3, 4);
 2912  0
                   break;
 2913  0
                default : break;
 2914   
             }
 2915  2
          } while(i != startsAt);
 2916   
       }
 2917  121231
       if (kind != 0x7fffffff)
 2918   
       {
 2919  110974
          jjmatchedKind = kind;
 2920  110974
          jjmatchedPos = curPos;
 2921  110974
          kind = 0x7fffffff;
 2922   
       }
 2923  121231
       ++curPos;
 2924  ?
       if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
 2925  10249
          return curPos;
 2926  110982
       try { curChar = input_stream.readChar(); }
 2927  0
       catch(java.io.IOException e) { return curPos; }
 2928   
    }
 2929   
 }
 2930  0
 private final int jjStopStringLiteralDfa_0(int pos, long active0)
 2931   
 {
 2932  0
    switch (pos)
 2933   
    {
 2934   
       default :
 2935  0
          return -1;
 2936   
    }
 2937   
 }
 2938  0
 private final int jjStartNfa_0(int pos, long active0)
 2939   
 {
 2940  0
    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
 2941   
 }
 2942  0
 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
 2943   
 {
 2944  0
    jjmatchedKind = kind;
 2945  0
    jjmatchedPos = pos;
 2946  0
    try { curChar = input_stream.readChar(); }
 2947  0
    catch(java.io.IOException e) { return pos + 1; }
 2948  0
    return jjMoveNfa_0(state, pos + 1);
 2949   
 }
 2950  87759
 private final int jjMoveStringLiteralDfa0_0()
 2951   
 {
 2952  87759
    switch(curChar)
 2953   
    {
 2954   
       case 34:
 2955  10255
          return jjStopAtPos(0, 32);
 2956   
       case 39:
 2957  0
          return jjStopAtPos(0, 33);
 2958   
       case 47:
 2959  4102
          return jjMoveStringLiteralDfa1_0(0x400000000L);
 2960   
       case 58:
 2961  9919
          return jjStopAtPos(0, 31);
 2962   
       case 61:
 2963  10255
          return jjStopAtPos(0, 30);
 2964   
       case 62:
 2965  9148
          return jjStopAtPos(0, 35);
 2966   
       default :
 2967  44080
          return jjMoveNfa_0(1, 0);
 2968   
    }
 2969   
 }
 2970  4102
 private final int jjMoveStringLiteralDfa1_0(long active0)
 2971   
 {
 2972  4102
    try { curChar = input_stream.readChar(); }
 2973   
    catch(java.io.IOException e) {
 2974  0
       jjStopStringLiteralDfa_0(0, active0);
 2975  0
       return 1;
 2976   
    }
 2977  4102
    switch(curChar)
 2978   
    {
 2979   
       case 62:
 2980  4102
          if ((active0 & 0x400000000L) != 0L)
 2981  4102
             return jjStopAtPos(1, 34);
 2982  0
          break;
 2983   
       default :
 2984  0
          break;
 2985   
    }
 2986  0
    return jjStartNfa_0(0, active0);
 2987   
 }
 2988  44080
 private final int jjMoveNfa_0(int startState, int curPos)
 2989   
 {
 2990  44080
    int[] nextStates;
 2991  44080
    int startsAt = 0;
 2992  44080
    jjnewStateCnt = 3;
 2993  44080
    int i = 1;
 2994  44080
    jjstateSet[0] = startState;
 2995  44080
    int j, kind = 0x7fffffff;
 2996  44080
    for (;;)
 2997   
    {
 2998  258679
       if (++jjround == 0x7fffffff)
 2999  0
          ReInitRounds();
 3000  258679
       if (curChar < 64)
 3001   
       {
 3002  51008
          long l = 1L << curChar;
 3003  51008
          MatchLoop: do
 3004   
          {
 3005  51008
             switch(jjstateSet[--i])
 3006   
             {
 3007   
                case 1:
 3008   
                case 0:
 3009  17174
                   if ((0x100002600L & l) == 0L)
 3010  401
                      break;
 3011  16773
                   kind = 1;
 3012  16773
                   jjCheckNAdd(0);
 3013  16773
                   break;
 3014   
                case 2:
 3015  33834
                   if ((0x3ff600000000000L & l) == 0L)
 3016  33424
                      break;
 3017  410
                   kind = 36;
 3018  410
                   jjstateSet[jjnewStateCnt++] = 2;
 3019  410
                   break;
 3020  0
                default : break;
 3021   
             }
 3022  51008
          } while(i != startsAt);
 3023   
       }
 3024  207671
       else if (curChar < 128)
 3025   
       {
 3026  207671
          long l = 1L << (curChar & 077);
 3027  207671
          MatchLoop: do
 3028   
          {
 3029  207671
             switch(jjstateSet[--i])
 3030   
             {
 3031   
                case 1:
 3032   
                case 2:
 3033  197416
                   if ((0x7fffffe87fffffeL & l) == 0L)
 3034  0
                      break;
 3035  197416
                   if (kind > 36)
 3036  197416
                      kind = 36;
 3037  197416
                   jjCheckNAdd(2);
 3038  197416
                   break;
 3039  10255
                default : break;
 3040   
             }
 3041  207671
          } while(i != startsAt);
 3042   
       }
 3043   
       else
 3044   
       {
 3045  0
          int hiByte = (int)(curChar >> 8);
 3046  0
          int i1 = hiByte >> 6;
 3047  0
          long l1 = 1L << (hiByte & 077);
 3048  0
          int i2 = (curChar & 0xff) >> 6;
 3049  0
          long l2 = 1L << (curChar & 077);
 3050  0
          MatchLoop: do
 3051   
          {
 3052  0
             switch(jjstateSet[--i])
 3053   
             {
 3054   
                case 1:
 3055  0
                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
 3056  0
                      break;
 3057  0
                   if (kind > 36)
 3058  0
                      kind = 36;
 3059  0
                   jjCheckNAdd(2);
 3060  0
                   break;
 3061   
                case 2:
 3062  0
                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
 3063  0
                      break;
 3064  0
                   if (kind > 36)
 3065  0
                      kind = 36;
 3066  0
                   jjCheckNAdd(2);
 3067  0
                   break;
 3068  0
                default : break;
 3069   
             }
 3070  0
          } while(i != startsAt);
 3071   
       }
 3072  258679
       if (kind != 0x7fffffff)
 3073   
       {
 3074  214599
          jjmatchedKind = kind;
 3075  214599
          jjmatchedPos = curPos;
 3076  214599
          kind = 0x7fffffff;
 3077   
       }
 3078  258679
       ++curPos;
 3079  ?
       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
 3080  44080
          return curPos;
 3081  214599
       try { curChar = input_stream.readChar(); }
 3082  0
       catch(java.io.IOException e) { return curPos; }
 3083   
    }
 3084   
 }
 3085   
 static final int[] jjnextStates = {
 3086   
    0, 1, 4, 9, 10, 3, 4, 7, 11, 12, 15, 9, 10, 25, 35, 95, 
 3087   
    17, 18, 27, 28, 37, 38, 40, 42, 65, 83, 84, 87, 44, 45, 58, 50, 
 3088   
    51, 67, 68, 76, 71, 72, 74, 69, 70, 77, 78, 85, 86, 88, 89, 44, 
 3089   
    52, 53, 54, 55, 58, 3, 4, 6, 19, 37, 8, 9, 12, 21, 22, 30, 
 3090   
    25, 26, 28, 46, 47, 50, 23, 24, 31, 32, 6, 12, 10, 11, 21, 27, 
 3091   
    13, 14, 7, 8, 11, 15, 16, 19, 25, 26, 2, 3, 5, 6, 
 3092   
 };
 3093  2
 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
 3094   
 {
 3095  2
    switch(hiByte)
 3096   
    {
 3097   
       case 0:
 3098  0
          return ((jjbitVec2[i2] & l2) != 0L);
 3099   
       default : 
 3100  2
          if ((jjbitVec0[i1] & l1) != 0L)
 3101  2
             return true;
 3102  0
          return false;
 3103   
    }
 3104   
 }
 3105  0
 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
 3106   
 {
 3107  0
    switch(hiByte)
 3108   
    {
 3109   
       case 0:
 3110  0
          return ((jjbitVec4[i2] & l2) != 0L);
 3111   
       case 1:
 3112  0
          return ((jjbitVec5[i2] & l2) != 0L);
 3113   
       case 2:
 3114  0
          return ((jjbitVec6[i2] & l2) != 0L);
 3115   
       case 3:
 3116  0
          return ((jjbitVec7[i2] & l2) != 0L);
 3117   
       case 4:
 3118  0
          return ((jjbitVec8[i2] & l2) != 0L);
 3119   
       case 5:
 3120  0
          return ((jjbitVec9[i2] & l2) != 0L);
 3121   
       case 6:
 3122  0
          return ((jjbitVec10[i2] & l2) != 0L);
 3123   
       case 9:
 3124  0
          return ((jjbitVec11[i2] & l2) != 0L);
 3125   
       case 10:
 3126  0
          return ((jjbitVec12[i2] & l2) != 0L);
 3127   
       case 11:
 3128  0
          return ((jjbitVec13[i2] & l2) != 0L);
 3129   
       case 12:
 3130  0
          return ((jjbitVec14[i2] & l2) != 0L);
 3131   
       case 13:
 3132  0
          return ((jjbitVec15[i2] & l2) != 0L);
 3133   
       case 14:
 3134  0
          return ((jjbitVec16[i2] & l2) != 0L);
 3135   
       case 15:
 3136  0
          return ((jjbitVec17[i2] & l2) != 0L);
 3137   
       case 16:
 3138  0
          return ((jjbitVec18[i2] & l2) != 0L);
 3139   
       case 17:
 3140  0
          return ((jjbitVec19[i2] & l2) != 0L);
 3141   
       case 30:
 3142  0
          return ((jjbitVec20[i2] & l2) != 0L);
 3143   
       case 31:
 3144  0
          return ((jjbitVec21[i2] & l2) != 0L);
 3145   
       case 33:
 3146  0
          return ((jjbitVec22[i2] & l2) != 0L);
 3147   
       case 48:
 3148  0
          return ((jjbitVec23[i2] & l2) != 0L);
 3149   
       case 49:
 3150  0
          return ((jjbitVec24[i2] & l2) != 0L);
 3151   
       case 159:
 3152  0
          return ((jjbitVec25[i2] & l2) != 0L);
 3153   
       case 215:
 3154  0
          return ((jjbitVec26[i2] & l2) != 0L);
 3155   
       default : 
 3156  0
          if ((jjbitVec3[i1] & l1) != 0L)
 3157  0
             return true;
 3158  0
          return false;
 3159   
    }
 3160   
 }
 3161  0
 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
 3162   
 {
 3163  0
    switch(hiByte)
 3164   
    {
 3165   
       case 0:
 3166  0
          return ((jjbitVec27[i2] & l2) != 0L);
 3167   
       case 1:
 3168  0
          return ((jjbitVec5[i2] & l2) != 0L);
 3169   
       case 2:
 3170  0
          return ((jjbitVec28[i2] & l2) != 0L);
 3171   
       case 3:
 3172  0
          return ((jjbitVec29[i2] & l2) != 0L);
 3173   
       case 4:
 3174  0
          return ((jjbitVec30[i2] & l2) != 0L);
 3175   
       case 5:
 3176  0
          return ((jjbitVec31[i2] & l2) != 0L);
 3177   
       case 6:
 3178  0
          return ((jjbitVec32[i2] & l2) != 0L);
 3179   
       case 9:
 3180  0
          return ((jjbitVec33[i2] & l2) != 0L);
 3181   
       case 10:
 3182  0
          return ((jjbitVec34[i2] & l2) != 0L);
 3183   
       case 11:
 3184  0
          return ((jjbitVec35[i2] & l2) != 0L);
 3185   
       case 12:
 3186  0
          return ((jjbitVec36[i2] & l2) != 0L);
 3187   
       case 13:
 3188  0
          return ((jjbitVec37[i2] & l2) != 0L);
 3189   
       case 14:
 3190  0
          return ((jjbitVec38[i2] & l2) != 0L);
 3191   
       case 15:
 3192  0
          return ((jjbitVec39[i2] & l2) != 0L);
 3193   
       case 16:
 3194  0
          return ((jjbitVec18[i2] & l2) != 0L);
 3195   
       case 17:
 3196  0
          return ((jjbitVec19[i2] & l2) != 0L);
 3197   
       case 30:
 3198  0
          return ((jjbitVec20[i2] & l2) != 0L);
 3199   
       case 31:
 3200  0
          return ((jjbitVec21[i2] & l2) != 0L);
 3201   
       case 32:
 3202  0
          return ((jjbitVec40[i2] & l2) != 0L);
 3203   
       case 33:
 3204  0
          return ((jjbitVec22[i2] & l2) != 0L);
 3205   
       case 48:
 3206  0
          return ((jjbitVec41[i2] & l2) != 0L);
 3207   
       case 49:
 3208  0
          return ((jjbitVec24[i2] & l2) != 0L);
 3209   
       case 159:
 3210  0
          return ((jjbitVec25[i2] & l2) != 0L);
 3211   
       case 215:
 3212  0
          return ((jjbitVec26[i2] & l2) != 0L);
 3213   
       default : 
 3214  0
          if ((jjbitVec3[i1] & l1) != 0L)
 3215  0
             return true;
 3216  0
          return false;
 3217   
    }
 3218   
 }
 3219   
 public static final String[] jjstrLiteralImages = {
 3220   
 "", null, "\74\77\170\155\154", null, "\74", null, null, null, "\74\57", null, 
 3221   
 "\74\41\133\103\104\101\124\101\133", null, "\42", null, "\47", null, null, null, null, null, null, "\135\135\76", 
 3222   
 "\76", "\133", null, null, "\135", null, null, null, "\75", "\72", "\42", "\47", 
 3223   
 "\57\76", "\76", null, null, null, null, null, null, null, null, "\77\76", 
 3224   
 "\166\145\162\163\151\157\156", "\145\156\143\157\144\151\156\147", 
 3225   
 "\163\164\141\156\144\141\154\157\156\145", "\75", null, };
 3226   
 public static final String[] lexStateNames = {
 3227   
    "TagState", 
 3228   
    "DocTypeState", 
 3229   
    "MarkupDeclState", 
 3230   
    "XmlDeclState", 
 3231   
    "DEFAULT", 
 3232   
    "ContentState", 
 3233   
    "DocTypeNameState", 
 3234   
    "AttStateQ", 
 3235   
    "AttStateA", 
 3236   
    "PiState", 
 3237   
    "DocTypeDeclStartState", 
 3238   
    "CDataState", 
 3239   
 };
 3240   
 public static final int[] jjnewLexState = {
 3241   
    -1, -1, 3, 1, 0, -1, -1, -1, 0, -1, 11, -1, 0, -1, 0, -1, -1, -1, -1, -1, -1, 5, 4, 2, -1, 
 3242   
    -1, 1, -1, -1, -1, -1, -1, 7, 8, 5, 5, -1, -1, -1, -1, -1, -1, -1, -1, 4, -1, -1, -1, -1, -1, 
 3243   
 };
 3244   
 static final long[] jjtoToken = {
 3245   
    0x3f01ffcf3fffdL, 
 3246   
 };
 3247   
 static final long[] jjtoSkip = {
 3248   
    0x2L, 
 3249   
 };
 3250   
 private SimpleCharStream input_stream;
 3251   
 private final int[] jjrounds = new int[96];
 3252   
 private final int[] jjstateSet = new int[192];
 3253   
 protected char curChar;
 3254  398
 public ParserTokenManager(SimpleCharStream stream)
 3255   
 {
 3256  398
    if (SimpleCharStream.staticFlag)
 3257  0
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 3258  398
    input_stream = stream;
 3259   
 }
 3260  0
 public ParserTokenManager(SimpleCharStream stream, int lexState)
 3261   
 {
 3262  0
    this(stream);
 3263  0
    SwitchTo(lexState);
 3264   
 }
 3265  69
 public void ReInit(SimpleCharStream stream)
 3266   
 {
 3267  69
    jjmatchedPos = jjnewStateCnt = 0;
 3268  69
    curLexState = defaultLexState;
 3269  69
    input_stream = stream;
 3270  69
    ReInitRounds();
 3271   
 }
 3272  69
 private final void ReInitRounds()
 3273   
 {
 3274  69
    int i;
 3275  69
    jjround = 0x80000001;
 3276  69
    for (i = 96; i-- > 0;)
 3277  6624
       jjrounds[i] = 0x80000000;
 3278   
 }
 3279  0
 public void ReInit(SimpleCharStream stream, int lexState)
 3280   
 {
 3281  0
    ReInit(stream);
 3282  0
    SwitchTo(lexState);
 3283   
 }
 3284  0
 public void SwitchTo(int lexState)
 3285   
 {
 3286  0
    if (lexState >= 12 || lexState < 0)
 3287  0
       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 3288   
    else
 3289  0
       curLexState = lexState;
 3290   
 }
 3291   
 
 3292  125187
 private final Token jjFillToken()
 3293   
 {
 3294  125187
    Token t = Token.newToken(jjmatchedKind);
 3295  125187
    t.kind = jjmatchedKind;
 3296  125187
    String im = jjstrLiteralImages[jjmatchedKind];
 3297  125187
    t.image = (im == null) ? input_stream.GetImage() : im;
 3298  125187
    t.beginLine = input_stream.getBeginLine();
 3299  125187
    t.beginColumn = input_stream.getBeginColumn();
 3300  125187
    t.endLine = input_stream.getEndLine();
 3301  125187
    t.endColumn = input_stream.getEndColumn();
 3302  125187
    return t;
 3303   
 }
 3304   
 
 3305   
 int curLexState = 4;
 3306   
 int defaultLexState = 4;
 3307   
 int jjnewStateCnt;
 3308   
 int jjround;
 3309   
 int jjmatchedPos;
 3310   
 int jjmatchedKind;
 3311   
 
 3312  125187
 public final Token getNextToken() 
 3313   
 {
 3314  125187
   int kind;
 3315  125187
   Token specialToken = null;
 3316  125187
   Token matchedToken;
 3317  125187
   int curPos = 0;
 3318   
 
 3319  125187
   EOFLoop :
 3320   
   for (;;)
 3321   
   {   
 3322  135994
    try   
 3323   
    {     
 3324  135994
       curChar = input_stream.BeginToken();
 3325   
    }     
 3326   
    catch(java.io.IOException e)
 3327   
    {        
 3328  31
       jjmatchedKind = 0;
 3329  31
       matchedToken = jjFillToken();
 3330  31
       return matchedToken;
 3331   
    }
 3332   
 
 3333  135963
    switch(curLexState)
 3334   
    {
 3335   
      case 0:
 3336  87759
        jjmatchedKind = 0x7fffffff;
 3337  87759
        jjmatchedPos = 0;
 3338  87759
        curPos = jjMoveStringLiteralDfa0_0();
 3339  87759
        break;
 3340   
      case 1:
 3341  17
        jjmatchedKind = 0x7fffffff;
 3342  17
        jjmatchedPos = 0;
 3343  17
        curPos = jjMoveStringLiteralDfa0_1();
 3344  17
        break;
 3345   
      case 2:
 3346  288
        jjmatchedKind = 0x7fffffff;
 3347  288
        jjmatchedPos = 0;
 3348  288
        curPos = jjMoveStringLiteralDfa0_2();
 3349  288
        break;
 3350   
      case 3:
 3351  0
        jjmatchedKind = 0x7fffffff;
 3352  0
        jjmatchedPos = 0;
 3353  0
        curPos = jjMoveStringLiteralDfa0_3();
 3354  0
        break;
 3355   
      case 4:
 3356  1427
        jjmatchedKind = 0x7fffffff;
 3357  1427
        jjmatchedPos = 0;
 3358  1427
        curPos = jjMoveStringLiteralDfa0_4();
 3359  1427
        break;
 3360   
      case 5:
 3361  25952
        jjmatchedKind = 0x7fffffff;
 3362  25952
        jjmatchedPos = 0;
 3363  25952
        curPos = jjMoveStringLiteralDfa0_5();
 3364  25952
        break;
 3365   
      case 6:
 3366  0
        jjmatchedKind = 0x7fffffff;
 3367  0
        jjmatchedPos = 0;
 3368  0
        curPos = jjMoveStringLiteralDfa0_6();
 3369  0
        break;
 3370   
      case 7:
 3371  20504
        jjmatchedKind = 0x7fffffff;
 3372  20504
        jjmatchedPos = 0;
 3373  20504
        curPos = jjMoveStringLiteralDfa0_7();
 3374  20504
        break;
 3375   
      case 8:
 3376  0
        jjmatchedKind = 0x7fffffff;
 3377  0
        jjmatchedPos = 0;
 3378  0
        curPos = jjMoveStringLiteralDfa0_8();
 3379  0
        break;
 3380   
      case 9:
 3381  0
        jjmatchedKind = 0x7fffffff;
 3382  0
        jjmatchedPos = 0;
 3383  0
        curPos = jjMoveStringLiteralDfa0_9();
 3384  0
        break;
 3385   
      case 10:
 3386  0
        jjmatchedKind = 0x7fffffff;
 3387  0
        jjmatchedPos = 0;
 3388  0
        curPos = jjMoveStringLiteralDfa0_10();
 3389  0
        break;
 3390   
      case 11:
 3391  16
        jjmatchedKind = 0x7fffffff;
 3392  16
        jjmatchedPos = 0;
 3393  16
        curPos = jjMoveStringLiteralDfa0_11();
 3394  16
        break;
 3395   
    }
 3396  135963
      if (jjmatchedKind != 0x7fffffff)
 3397   
      {
 3398  135963
         if (jjmatchedPos + 1 < curPos)
 3399  76237
            input_stream.backup(curPos - jjmatchedPos - 1);
 3400  135963
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 3401   
         {
 3402  125156
            matchedToken = jjFillToken();
 3403  125156
        if (jjnewLexState[jjmatchedKind] != -1)
 3404  47046
          curLexState = jjnewLexState[jjmatchedKind];
 3405  125156
            return matchedToken;
 3406   
         }
 3407   
         else
 3408   
         {
 3409  10807
          if (jjnewLexState[jjmatchedKind] != -1)
 3410  0
            curLexState = jjnewLexState[jjmatchedKind];
 3411  10807
            continue EOFLoop;
 3412   
         }
 3413   
      }
 3414  0
      int error_line = input_stream.getEndLine();
 3415  0
      int error_column = input_stream.getEndColumn();
 3416  0
      String error_after = null;
 3417  0
      boolean EOFSeen = false;
 3418  0
      try { input_stream.readChar(); input_stream.backup(1); }
 3419   
      catch (java.io.IOException e1) {
 3420  0
         EOFSeen = true;
 3421  0
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 3422  0
         if (curChar == '\n' || curChar == '\r') {
 3423  0
            error_line++;
 3424  0
            error_column = 0;
 3425   
         }
 3426   
         else
 3427  0
            error_column++;
 3428   
      }
 3429  0
      if (!EOFSeen) {
 3430  0
         input_stream.backup(1);
 3431  0
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 3432   
      }
 3433  0
      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 3434   
   }
 3435   
 }
 3436   
 
 3437   
 }
 3438