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