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