Clover coverage report - XJavaDoc - 1.1
Coverage timestamp: Sun Oct 3 2004 19:56:54 BST
file stats: LOC: 1,730   Methods: 41
NCLOC: 1,721   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
SimpleParserTokenManager.java 47.4% 60.7% 80.5% 57%
coverage coverage
 1   
 /* Generated By:JavaCC: Do not edit this line. SimpleParserTokenManager.java */
 2   
 package xjavadoc;
 3   
 import java.lang.reflect.Modifier;
 4   
 import java.util.*;
 5   
 import java.io.InputStream;
 6   
 import java.io.ByteArrayInputStream;
 7   
 
 8   
 public class SimpleParserTokenManager implements SimpleParserConstants
 9   
 {
 10   
   public  java.io.PrintStream debugStream = System.out;
 11  0
   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
 12  60526
 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
 13   
 {
 14  60526
    switch (pos)
 15   
    {
 16   
       case 0:
 17  44424
          if ((active0 & 0x140L) != 0L || (active1 & 0x4008000000000L) != 0L)
 18  34
             return 2;
 19  44390
          if ((active1 & 0x100000L) != 0L)
 20  0
             return 8;
 21  44390
          if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L)
 22   
          {
 23  31352
             jjmatchedKind = 73;
 24  31352
             return 32;
 25   
          }
 26  13038
          return -1;
 27   
       case 1:
 28  8548
          if ((active0 & 0x100L) != 0L)
 29  0
             return 0;
 30  8548
          if ((active0 & 0xfffffffbfcffe000L) != 0L || (active1 & 0x1L) != 0L)
 31   
          {
 32  7666
             if (jjmatchedPos != 1)
 33   
             {
 34  7666
                jjmatchedKind = 73;
 35  7666
                jjmatchedPos = 1;
 36   
             }
 37  7666
             return 32;
 38   
          }
 39  882
          if ((active0 & 0x403000000L) != 0L)
 40  882
             return 32;
 41  0
          return -1;
 42   
       case 2:
 43  3238
          if ((active0 & 0xf7fffb3afeffe000L) != 0L || (active1 & 0x1L) != 0L)
 44   
          {
 45  1854
             if (jjmatchedPos != 2)
 46   
             {
 47  1854
                jjmatchedKind = 73;
 48  1854
                jjmatchedPos = 2;
 49   
             }
 50  1854
             return 32;
 51   
          }
 52  1384
          if ((active0 & 0x80004c100000000L) != 0L)
 53  1384
             return 32;
 54  0
          return -1;
 55   
       case 3:
 56  572
          if ((active0 & 0xe3bff2b8faf4e000L) != 0L || (active1 & 0x1L) != 0L)
 57   
          {
 58  572
             jjmatchedKind = 73;
 59  572
             jjmatchedPos = 3;
 60  572
             return 32;
 61   
          }
 62  0
          if ((active0 & 0x14400902040b0000L) != 0L)
 63  0
             return 32;
 64  0
          return -1;
 65   
       case 4:
 66  3376
          if ((active0 & 0xa235f2b80ac06000L) != 0L || (active1 & 0x1L) != 0L)
 67   
          {
 68  44
             if (jjmatchedPos != 4)
 69   
             {
 70  44
                jjmatchedKind = 73;
 71  44
                jjmatchedPos = 4;
 72   
             }
 73  44
             return 32;
 74   
          }
 75  3332
          if ((active0 & 0x418a0000f0348000L) != 0L)
 76  3332
             return 32;
 77  0
          return -1;
 78   
       case 5:
 79  0
          if ((active0 & 0xa22070a848c06000L) != 0L)
 80   
          {
 81  0
             jjmatchedKind = 73;
 82  0
             jjmatchedPos = 5;
 83  0
             return 32;
 84   
          }
 85  0
          if ((active0 & 0x115821002000000L) != 0L || (active1 & 0x1L) != 0L)
 86  0
             return 32;
 87  0
          return -1;
 88   
       case 6:
 89  44
          if ((active0 & 0xa22040a800402000L) != 0L)
 90   
          {
 91  44
             jjmatchedKind = 73;
 92  44
             jjmatchedPos = 6;
 93  44
             return 32;
 94   
          }
 95  0
          if ((active0 & 0x300048804000L) != 0L)
 96  0
             return 32;
 97  0
          return -1;
 98   
       case 7:
 99  280
          if ((active0 & 0x22040a800000000L) != 0L)
 100   
          {
 101  280
             jjmatchedKind = 73;
 102  280
             jjmatchedPos = 7;
 103  280
             return 32;
 104   
          }
 105  0
          if ((active0 & 0xa000000000402000L) != 0L)
 106  0
             return 32;
 107  0
          return -1;
 108   
       case 8:
 109  44
          if ((active0 & 0x20002800000000L) != 0L)
 110   
          {
 111  44
             jjmatchedKind = 73;
 112  44
             jjmatchedPos = 8;
 113  44
             return 32;
 114   
          }
 115  0
          if ((active0 & 0x200408000000000L) != 0L)
 116  0
             return 32;
 117  0
          return -1;
 118   
       case 9:
 119  0
          if ((active0 & 0x20000000000000L) != 0L)
 120   
          {
 121  0
             jjmatchedKind = 73;
 122  0
             jjmatchedPos = 9;
 123  0
             return 32;
 124   
          }
 125  0
          if ((active0 & 0x2800000000L) != 0L)
 126  0
             return 32;
 127  0
          return -1;
 128   
       case 10:
 129  0
          if ((active0 & 0x20000000000000L) != 0L)
 130   
          {
 131  0
             jjmatchedKind = 73;
 132  0
             jjmatchedPos = 10;
 133  0
             return 32;
 134   
          }
 135  0
          return -1;
 136   
       default :
 137  0
          return -1;
 138   
    }
 139   
 }
 140  60526
 private final int jjStartNfa_0(int pos, long active0, long active1)
 141   
 {
 142  60526
    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
 143   
 }
 144  606228
 private final int jjStopAtPos(int pos, int kind)
 145   
 {
 146  606228
    jjmatchedKind = kind;
 147  606228
    jjmatchedPos = pos;
 148  606228
    return pos + 1;
 149   
 }
 150  65376
 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
 151   
 {
 152  65376
    jjmatchedKind = kind;
 153  65376
    jjmatchedPos = pos;
 154  65376
    try { curChar = input_stream.readChar(); }
 155  0
    catch(java.io.IOException e) { return pos + 1; }
 156  65376
    return jjMoveNfa_0(state, pos + 1);
 157   
 }
 158  776908
 private final int jjMoveStringLiteralDfa0_0()
 159   
 {
 160  776908
    switch(curChar)
 161   
    {
 162   
       case 9:
 163  127284
          return jjStopAtPos(0, 2);
 164   
       case 10:
 165  82560
          return jjStopAtPos(0, 3);
 166   
       case 12:
 167  0
          return jjStopAtPos(0, 5);
 168   
       case 13:
 169  81888
          return jjStopAtPos(0, 4);
 170   
       case 32:
 171  174236
          return jjStopAtPos(0, 1);
 172   
       case 33:
 173  2384
          jjmatchedKind = 88;
 174  2384
          return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
 175   
       case 37:
 176  0
          jjmatchedKind = 107;
 177  0
          return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
 178   
       case 38:
 179  594
          jjmatchedKind = 104;
 180  594
          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L);
 181   
       case 40:
 182  34940
          return jjStopAtPos(0, 76);
 183   
       case 41:
 184  34940
          return jjStopAtPos(0, 77);
 185   
       case 42:
 186  336
          jjmatchedKind = 102;
 187  336
          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
 188   
       case 43:
 189  2492
          jjmatchedKind = 100;
 190  2492
          return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L);
 191   
       case 44:
 192  4170
          return jjStopAtPos(0, 83);
 193   
       case 45:
 194  172
          jjmatchedKind = 101;
 195  172
          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000800000000L);
 196   
       case 46:
 197  17834
          return jjStartNfaWithStates_0(0, 84, 8);
 198   
       case 47:
 199  9606
          jjmatchedKind = 103;
 200  9606
          return jjMoveStringLiteralDfa1_0(0x140L, 0x4000000000000L);
 201   
       case 58:
 202  316
          return jjStopAtPos(0, 91);
 203   
       case 59:
 204  25910
          return jjStopAtPos(0, 82);
 205   
       case 60:
 206  320
          jjmatchedKind = 87;
 207  320
          return jjMoveStringLiteralDfa1_0(0x0L, 0x80100020000000L);
 208   
       case 61:
 209  10848
          jjmatchedKind = 85;
 210  10848
          return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
 211   
       case 62:
 212  64
          jjmatchedKind = 86;
 213  64
          return jjMoveStringLiteralDfa1_0(0x0L, 0x300600040000000L);
 214   
       case 63:
 215  284
          return jjStopAtPos(0, 90);
 216   
       case 91:
 217  354
          return jjStopAtPos(0, 80);
 218   
       case 93:
 219  354
          return jjStopAtPos(0, 81);
 220   
       case 94:
 221  0
          jjmatchedKind = 106;
 222  0
          return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
 223   
       case 97:
 224  3734
          return jjMoveStringLiteralDfa1_0(0x2000L, 0x1L);
 225   
       case 98:
 226  3256
          return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L);
 227   
       case 99:
 228  4316
          return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L);
 229   
       case 100:
 230  1202
          return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L);
 231   
       case 101:
 232  3404
          return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L);
 233   
       case 102:
 234  6286
          return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L);
 235   
       case 103:
 236  8774
          return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L);
 237   
       case 105:
 238  15680
          return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L);
 239   
       case 108:
 240  1004
          return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L);
 241   
       case 110:
 242  8308
          return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L);
 243   
       case 112:
 244  11050
          return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L);
 245   
       case 114:
 246  5952
          return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
 247   
       case 115:
 248  5914
          return jjMoveStringLiteralDfa1_0(0x803e000000000000L, 0x0L);
 249   
       case 116:
 250  6692
          return jjMoveStringLiteralDfa1_0(0xfc0000000000000L, 0x0L);
 251   
       case 118:
 252  2630
          return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L);
 253   
       case 119:
 254  546
          return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L);
 255   
       case 123:
 256  12524
          return jjStopAtPos(0, 78);
 257   
       case 124:
 258  200
          jjmatchedKind = 105;
 259  200
          return jjMoveStringLiteralDfa1_0(0x0L, 0x10000100000000L);
 260   
       case 125:
 261  12524
          return jjStopAtPos(0, 79);
 262   
       case 126:
 263  0
          return jjStopAtPos(0, 89);
 264   
       default :
 265  51026
          return jjMoveNfa_0(3, 0);
 266   
    }
 267   
 }
 268  115764
 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
 269   
 {
 270  115764
    try { curChar = input_stream.readChar(); }
 271   
    catch(java.io.IOException e) {
 272  0
       jjStopStringLiteralDfa_0(0, active0, active1);
 273  0
       return 1;
 274   
    }
 275  115764
    switch(curChar)
 276   
    {
 277   
       case 38:
 278  382
          if ((active1 & 0x200000000L) != 0L)
 279  382
             return jjStopAtPos(1, 97);
 280  0
          break;
 281   
       case 42:
 282  6248
          if ((active0 & 0x100L) != 0L)
 283  6248
             return jjStartNfaWithStates_0(1, 8, 0);
 284  0
          break;
 285   
       case 43:
 286  448
          if ((active1 & 0x400000000L) != 0L)
 287  266
             return jjStopAtPos(1, 98);
 288  182
          break;
 289   
       case 45:
 290  0
          if ((active1 & 0x800000000L) != 0L)
 291  0
             return jjStopAtPos(1, 99);
 292  0
          break;
 293   
       case 47:
 294  3324
          if ((active0 & 0x40L) != 0L)
 295  3324
             return jjStopAtPos(1, 6);
 296  0
          break;
 297   
       case 60:
 298  0
          if ((active1 & 0x100000000000L) != 0L)
 299   
          {
 300  0
             jjmatchedKind = 108;
 301  0
             jjmatchedPos = 1;
 302   
          }
 303  0
          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000000L);
 304   
       case 61:
 305  3556
          if ((active1 & 0x10000000L) != 0L)
 306  1674
             return jjStopAtPos(1, 92);
 307  1882
          else if ((active1 & 0x20000000L) != 0L)
 308  14
             return jjStopAtPos(1, 93);
 309  1868
          else if ((active1 & 0x40000000L) != 0L)
 310  40
             return jjStopAtPos(1, 94);
 311  1828
          else if ((active1 & 0x80000000L) != 0L)
 312  1750
             return jjStopAtPos(1, 95);
 313  78
          else if ((active1 & 0x800000000000L) != 0L)
 314  46
             return jjStopAtPos(1, 111);
 315  32
          else if ((active1 & 0x1000000000000L) != 0L)
 316  0
             return jjStopAtPos(1, 112);
 317  32
          else if ((active1 & 0x2000000000000L) != 0L)
 318  0
             return jjStopAtPos(1, 113);
 319  32
          else if ((active1 & 0x4000000000000L) != 0L)
 320  0
             return jjStopAtPos(1, 114);
 321  32
          else if ((active1 & 0x8000000000000L) != 0L)
 322  0
             return jjStopAtPos(1, 115);
 323  32
          else if ((active1 & 0x10000000000000L) != 0L)
 324  32
             return jjStopAtPos(1, 116);
 325  0
          else if ((active1 & 0x20000000000000L) != 0L)
 326  0
             return jjStopAtPos(1, 117);
 327  0
          else if ((active1 & 0x40000000000000L) != 0L)
 328  0
             return jjStopAtPos(1, 118);
 329  0
          break;
 330   
       case 62:
 331  0
          if ((active1 & 0x200000000000L) != 0L)
 332   
          {
 333  0
             jjmatchedKind = 109;
 334  0
             jjmatchedPos = 1;
 335   
          }
 336  0
          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x300400000000000L);
 337   
       case 97:
 338  6762
          return jjMoveStringLiteralDfa2_0(active0, 0x120010060000L, active1, 0L);
 339   
       case 98:
 340  566
          return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
 341   
       case 101:
 342  19922
          return jjMoveStringLiteralDfa2_0(active0, 0x1040000800000L, active1, 0L);
 343   
       case 102:
 344  3912
          if ((active0 & 0x400000000L) != 0L)
 345  3904
             return jjStartNfaWithStates_0(1, 34, 32);
 346  8
          break;
 347   
       case 104:
 348  2390
          return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000L, active1, 0L);
 349   
       case 105:
 350  4468
          return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0L);
 351   
       case 108:
 352  3604
          return jjMoveStringLiteralDfa2_0(active0, 0x84100000L, active1, 0L);
 353   
       case 109:
 354  2502
          return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L);
 355   
       case 110:
 356  3816
          return jjMoveStringLiteralDfa2_0(active0, 0xe000000000L, active1, 0L);
 357   
       case 111:
 358  10490
          if ((active0 & 0x1000000L) != 0L)
 359   
          {
 360  882
             jjmatchedKind = 24;
 361  882
             jjmatchedPos = 1;
 362   
          }
 363  10490
          return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000L, active1, 0L);
 364   
       case 114:
 365  5502
          return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000L, active1, 0L);
 366   
       case 115:
 367  2246
          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1L);
 368   
       case 116:
 369  3190
          return jjMoveStringLiteralDfa2_0(active0, 0x8004000000000000L, active1, 0L);
 370   
       case 117:
 371  12634
          return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000L, active1, 0L);
 372   
       case 119:
 373  124
          return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 0L);
 374   
       case 120:
 375  590
          return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0L);
 376   
       case 121:
 377  56
          return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000L, active1, 0L);
 378   
       case 124:
 379  168
          if ((active1 & 0x100000000L) != 0L)
 380  168
             return jjStopAtPos(1, 96);
 381  0
          break;
 382   
       default :
 383  18864
          break;
 384   
    }
 385  19054
    return jjStartNfa_0(0, active0, active1);
 386   
 }
 387  78862
 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
 388   
 {
 389  78862
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 390  25370
       return jjStartNfa_0(0, old0, old1); 
 391  53492
    try { curChar = input_stream.readChar(); }
 392   
    catch(java.io.IOException e) {
 393  0
       jjStopStringLiteralDfa_0(1, active0, active1);
 394  0
       return 2;
 395   
    }
 396  53492
    switch(curChar)
 397   
    {
 398   
       case 61:
 399  0
          if ((active1 & 0x80000000000000L) != 0L)
 400  0
             return jjStopAtPos(2, 119);
 401  0
          else if ((active1 & 0x100000000000000L) != 0L)
 402  0
             return jjStopAtPos(2, 120);
 403  0
          break;
 404   
       case 62:
 405  0
          if ((active1 & 0x400000000000L) != 0L)
 406   
          {
 407  0
             jjmatchedKind = 110;
 408  0
             jjmatchedPos = 2;
 409   
          }
 410  0
          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000000000000L);
 411   
       case 97:
 412  3062
          return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000L, active1, 0L);
 413   
       case 98:
 414  5276
          return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0L);
 415   
       case 99:
 416  1382
          return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L);
 417   
       case 101:
 418  852
          return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L);
 419   
       case 102:
 420  188
          return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L);
 421   
       case 105:
 422  6288
          return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000L, active1, 0L);
 423   
       case 108:
 424  5312
          return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000L, active1, 0L);
 425   
       case 110:
 426  4130
          return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000L, active1, 0L);
 427   
       case 111:
 428  3374
          return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000L, active1, 0L);
 429   
       case 112:
 430  4468
          return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000L, active1, 0L);
 431   
       case 114:
 432  2930
          if ((active0 & 0x100000000L) != 0L)
 433  1042
             return jjStartNfaWithStates_0(2, 32, 32);
 434  1888
          return jjMoveStringLiteralDfa3_0(active0, 0x8180000000000000L, active1, 0L);
 435   
       case 115:
 436  2620
          return jjMoveStringLiteralDfa3_0(active0, 0x2004022000L, active1, 0x1L);
 437   
       case 116:
 438  7434
          if ((active0 & 0x4000000000L) != 0L)
 439   
          {
 440  2252
             jjmatchedKind = 38;
 441  2252
             jjmatchedPos = 2;
 442   
          }
 443  7434
          return jjMoveStringLiteralDfa3_0(active0, 0x1028208050000L, active1, 0L);
 444   
       case 117:
 445  608
          return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000L, active1, 0L);
 446   
       case 119:
 447  2752
          if ((active0 & 0x40000000000L) != 0L)
 448  2752
             return jjStartNfaWithStates_0(2, 42, 32);
 449  0
          break;
 450   
       case 121:
 451  134
          if ((active0 & 0x800000000000000L) != 0L)
 452  134
             return jjStartNfaWithStates_0(2, 59, 32);
 453  0
          break;
 454   
       default :
 455  2682
          break;
 456   
    }
 457  2682
    return jjStartNfa_0(1, active0, active1);
 458   
 }
 459  46882
 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
 460   
 {
 461  46882
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 462  5866
       return jjStartNfa_0(1, old0, old1); 
 463  41016
    try { curChar = input_stream.readChar(); }
 464   
    catch(java.io.IOException e) {
 465  0
       jjStopStringLiteralDfa_0(2, active0, active1);
 466  0
       return 3;
 467   
    }
 468  41016
    switch(curChar)
 469   
    {
 470   
       case 61:
 471  0
          if ((active1 & 0x200000000000000L) != 0L)
 472  0
             return jjStopAtPos(3, 121);
 473  0
          break;
 474   
       case 97:
 475  2734
          return jjMoveStringLiteralDfa4_0(active0, 0x20000000e0808000L, active1, 0L);
 476   
       case 98:
 477  0
          return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L);
 478   
       case 99:
 479  174
          return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000L, active1, 0L);
 480   
       case 100:
 481  1894
          if ((active0 & 0x1000000000000000L) != 0L)
 482  1870
             return jjStartNfaWithStates_0(3, 60, 32);
 483  24
          break;
 484   
       case 101:
 485  5270
          if ((active0 & 0x10000L) != 0L)
 486  0
             return jjStartNfaWithStates_0(3, 16, 32);
 487  5270
          else if ((active0 & 0x20000L) != 0L)
 488  0
             return jjStartNfaWithStates_0(3, 17, 32);
 489  5270
          else if ((active0 & 0x4000000L) != 0L)
 490  1136
             return jjStartNfaWithStates_0(3, 26, 32);
 491  4134
          else if ((active0 & 0x400000000000000L) != 0L)
 492  548
             return jjStartNfaWithStates_0(3, 58, 32);
 493  3586
          return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000L, active1, 0x1L);
 494   
       case 103:
 495  132
          if ((active0 & 0x10000000000L) != 0L)
 496  132
             return jjStartNfaWithStates_0(3, 40, 32);
 497  0
          break;
 498   
       case 105:
 499  146
          return jjMoveStringLiteralDfa4_0(active0, 0x8000020000000000L, active1, 0L);
 500   
       case 107:
 501  724
          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
 502   
       case 108:
 503  12564
          if ((active0 & 0x80000000000L) != 0L)
 504  4126
             return jjStartNfaWithStates_0(3, 43, 32);
 505  8438
          return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000L, active1, 0L);
 506   
       case 110:
 507  664
          return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L, active1, 0L);
 508   
       case 111:
 509  3104
          if ((active0 & 0x200000000L) != 0L)
 510  0
             return jjStartNfaWithStates_0(3, 33, 32);
 511  3104
          return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000L, active1, 0L);
 512   
       case 114:
 513  204
          if ((active0 & 0x80000L) != 0L)
 514  146
             return jjStartNfaWithStates_0(3, 19, 32);
 515  58
          return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
 516   
       case 115:
 517  2554
          if ((active0 & 0x40000000000000L) != 0L)
 518  540
             return jjStartNfaWithStates_0(3, 54, 32);
 519  2014
          return jjMoveStringLiteralDfa4_0(active0, 0x10300000L, active1, 0L);
 520   
       case 116:
 521  1850
          return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000L, active1, 0L);
 522   
       case 117:
 523  4060
          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
 524   
       case 118:
 525  2502
          return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
 526   
       default :
 527  2440
          break;
 528   
    }
 529  2464
    return jjStartNfa_0(2, active0, active1);
 530   
 }
 531  30054
 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
 532   
 {
 533  30054
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 534  774
       return jjStartNfa_0(2, old0, old1); 
 535  29280
    try { curChar = input_stream.readChar(); }
 536   
    catch(java.io.IOException e) {
 537  0
       jjStopStringLiteralDfa_0(3, active0, active1);
 538  0
       return 4;
 539   
    }
 540  29280
    switch(curChar)
 541   
    {
 542   
       case 97:
 543  4114
          return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0L);
 544   
       case 99:
 545  0
          return jjMoveStringLiteralDfa5_0(active0, 0x8010000000000000L, active1, 0L);
 546   
       case 101:
 547  4396
          if ((active0 & 0x10000000L) != 0L)
 548  628
             return jjStartNfaWithStates_0(4, 28, 32);
 549  3768
          else if ((active0 & 0x4000000000000000L) != 0L)
 550  370
             return jjStartNfaWithStates_0(4, 62, 32);
 551  3398
          return jjMoveStringLiteralDfa5_0(active0, 0x400800004000L, active1, 0L);
 552   
       case 104:
 553  174
          if ((active0 & 0x40000L) != 0L)
 554  174
             return jjStartNfaWithStates_0(4, 18, 32);
 555  0
          return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0L);
 556   
       case 105:
 557  5538
          return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000L, active1, 0L);
 558   
       case 107:
 559  74
          if ((active0 & 0x8000L) != 0L)
 560  74
             return jjStartNfaWithStates_0(4, 15, 32);
 561  0
          break;
 562   
       case 108:
 563  2660
          if ((active0 & 0x20000000L) != 0L)
 564   
          {
 565  2660
             jjmatchedKind = 29;
 566  2660
             jjmatchedPos = 4;
 567   
          }
 568  2660
          return jjMoveStringLiteralDfa5_0(active0, 0x42000000L, active1, 0L);
 569   
       case 110:
 570  528
          return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L);
 571   
       case 114:
 572  9212
          if ((active0 & 0x8000000000000L) != 0L)
 573  2176
             return jjStartNfaWithStates_0(4, 51, 32);
 574  7036
          return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000L, active1, 0x1L);
 575   
       case 115:
 576  1222
          if ((active0 & 0x100000L) != 0L)
 577  1178
             return jjStartNfaWithStates_0(4, 20, 32);
 578  44
          return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L);
 579   
       case 116:
 580  208
          if ((active0 & 0x200000L) != 0L)
 581  208
             return jjStartNfaWithStates_0(4, 21, 32);
 582  0
          else if ((active0 & 0x80000000L) != 0L)
 583  0
             return jjStartNfaWithStates_0(4, 31, 32);
 584  0
          else if ((active0 & 0x2000000000000L) != 0L)
 585  0
             return jjStartNfaWithStates_0(4, 49, 32);
 586  0
          return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0L);
 587   
       case 117:
 588  0
          return jjMoveStringLiteralDfa5_0(active0, 0x800000L, active1, 0L);
 589   
       case 118:
 590  0
          return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L, active1, 0L);
 591   
       case 119:
 592  1154
          if ((active0 & 0x80000000000000L) != 0L)
 593   
          {
 594  1154
             jjmatchedKind = 55;
 595  1154
             jjmatchedPos = 4;
 596   
          }
 597  1154
          return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L);
 598   
       default :
 599  0
          break;
 600   
    }
 601  0
    return jjStartNfa_0(3, active0, active1);
 602   
 }
 603  24472
 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
 604   
 {
 605  24472
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 606  572
       return jjStartNfa_0(3, old0, old1); 
 607  23900
    try { curChar = input_stream.readChar(); }
 608   
    catch(java.io.IOException e) {
 609  0
       jjStopStringLiteralDfa_0(4, active0, active1);
 610  0
       return 5;
 611   
    }
 612  23900
    switch(curChar)
 613   
    {
 614   
       case 97:
 615  2810
          return jjMoveStringLiteralDfa6_0(active0, 0x6000L, active1, 0L);
 616   
       case 99:
 617  5952
          if ((active0 & 0x800000000000L) != 0L)
 618  5096
             return jjStartNfaWithStates_0(5, 47, 32);
 619  856
          else if ((active0 & 0x4000000000000L) != 0L)
 620  430
             return jjStartNfaWithStates_0(5, 50, 32);
 621  426
          return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
 622   
       case 100:
 623  478
          return jjMoveStringLiteralDfa6_0(active0, 0x8000000L, active1, 0L);
 624   
       case 101:
 625  0
          if ((active0 & 0x2000000L) != 0L)
 626  0
             return jjStartNfaWithStates_0(5, 25, 32);
 627  0
          else if ((active0 & 0x20000000000L) != 0L)
 628  0
             return jjStartNfaWithStates_0(5, 41, 32);
 629  0
          break;
 630   
       case 102:
 631  912
          return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
 632   
       case 103:
 633  724
          return jjMoveStringLiteralDfa6_0(active0, 0x100000000000L, active1, 0L);
 634   
       case 104:
 635  0
          if ((active0 & 0x10000000000000L) != 0L)
 636  0
             return jjStartNfaWithStates_0(5, 52, 32);
 637  0
          break;
 638   
       case 105:
 639  0
          return jjMoveStringLiteralDfa6_0(active0, 0x2200000000000000L, active1, 0L);
 640   
       case 108:
 641  0
          return jjMoveStringLiteralDfa6_0(active0, 0x40800000L, active1, 0L);
 642   
       case 109:
 643  256
          return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0L);
 644   
       case 110:
 645  4458
          if ((active0 & 0x1000000000000L) != 0L)
 646  4060
             return jjStartNfaWithStates_0(5, 48, 32);
 647  398
          return jjMoveStringLiteralDfa6_0(active0, 0x2000400000L, active1, 0L);
 648   
       case 114:
 649  0
          return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L);
 650   
       case 115:
 651  482
          if ((active0 & 0x100000000000000L) != 0L)
 652  482
             return jjStartNfaWithStates_0(5, 56, 32);
 653  0
          break;
 654   
       case 116:
 655  4516
          if ((active0 & 0x1000000000L) != 0L)
 656  1950
             return jjStartNfaWithStates_0(5, 36, 32);
 657  2566
          else if ((active1 & 0x1L) != 0L)
 658  64
             return jjStartNfaWithStates_0(5, 64, 32);
 659  2502
          return jjMoveStringLiteralDfa6_0(active0, 0x8000200000000000L, active1, 0L);
 660   
       default :
 661  3312
          break;
 662   
    }
 663  3312
    return jjStartNfa_0(4, active0, active1);
 664   
 }
 665  8506
 private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
 666   
 {
 667  8506
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 668  64
       return jjStartNfa_0(4, old0, old1); 
 669  8442
    try { curChar = input_stream.readChar(); }
 670   
    catch(java.io.IOException e) {
 671  0
       jjStopStringLiteralDfa_0(5, active0, 0L);
 672  0
       return 6;
 673   
    }
 674  8442
    switch(curChar)
 675   
    {
 676   
       case 97:
 677  868
          return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L);
 678   
       case 99:
 679  460
          return jjMoveStringLiteralDfa7_0(active0, 0x2000002000L);
 680   
       case 101:
 681  3482
          if ((active0 & 0x100000000000L) != 0L)
 682  724
             return jjStartNfaWithStates_0(6, 44, 32);
 683  2758
          else if ((active0 & 0x200000000000L) != 0L)
 684  2502
             return jjStartNfaWithStates_0(6, 45, 32);
 685  256
          return jjMoveStringLiteralDfa7_0(active0, 0x200000800000000L);
 686   
       case 102:
 687  0
          return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L);
 688   
       case 108:
 689  0
          return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L);
 690   
       case 110:
 691  2716
          if ((active0 & 0x4000L) != 0L)
 692  2716
             return jjStartNfaWithStates_0(6, 14, 32);
 693  0
          break;
 694   
       case 111:
 695  0
          return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L);
 696   
       case 115:
 697  478
          if ((active0 & 0x8000000L) != 0L)
 698  478
             return jjStartNfaWithStates_0(6, 27, 32);
 699  0
          break;
 700   
       case 116:
 701  426
          if ((active0 & 0x800000L) != 0L)
 702  0
             return jjStartNfaWithStates_0(6, 23, 32);
 703  426
          return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L);
 704   
       case 117:
 705  12
          return jjMoveStringLiteralDfa7_0(active0, 0x400000L);
 706   
       case 121:
 707  0
          if ((active0 & 0x40000000L) != 0L)
 708  0
             return jjStartNfaWithStates_0(6, 30, 32);
 709  0
          break;
 710   
       default :
 711  0
          break;
 712   
    }
 713  0
    return jjStartNfa_0(5, active0, 0L);
 714   
 }
 715  2022
 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
 716   
 {
 717  2022
    if (((active0 &= old0)) == 0L)
 718  0
       return jjStartNfa_0(5, old0, 0L);
 719  2022
    try { curChar = input_stream.readChar(); }
 720   
    catch(java.io.IOException e) {
 721  0
       jjStopStringLiteralDfa_0(6, active0, 0L);
 722  0
       return 7;
 723   
    }
 724  2022
    switch(curChar)
 725   
    {
 726   
       case 99:
 727  824
          return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L);
 728   
       case 101:
 729  804
          if ((active0 & 0x400000L) != 0L)
 730  12
             return jjStartNfaWithStates_0(7, 22, 32);
 731  792
          else if ((active0 & 0x2000000000000000L) != 0L)
 732  0
             return jjStartNfaWithStates_0(7, 61, 32);
 733  792
          return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L);
 734   
       case 110:
 735  256
          return jjMoveStringLiteralDfa8_0(active0, 0x220000800000000L);
 736   
       case 112:
 737  0
          if ((active0 & 0x8000000000000000L) != 0L)
 738  0
             return jjStartNfaWithStates_0(7, 63, 32);
 739  0
          break;
 740   
       case 116:
 741  94
          if ((active0 & 0x2000L) != 0L)
 742  94
             return jjStartNfaWithStates_0(7, 13, 32);
 743  0
          break;
 744   
       default :
 745  44
          break;
 746   
    }
 747  44
    return jjStartNfa_0(6, active0, 0L);
 748   
 }
 749  1872
 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
 750   
 {
 751  1872
    if (((active0 &= old0)) == 0L)
 752  0
       return jjStartNfa_0(6, old0, 0L);
 753  1872
    try { curChar = input_stream.readChar(); }
 754   
    catch(java.io.IOException e) {
 755  0
       jjStopStringLiteralDfa_0(7, active0, 0L);
 756  0
       return 8;
 757   
    }
 758  1872
    switch(curChar)
 759   
    {
 760   
       case 100:
 761  426
          if ((active0 & 0x400000000000L) != 0L)
 762  426
             return jjStartNfaWithStates_0(8, 46, 32);
 763  0
          break;
 764   
       case 101:
 765  824
          if ((active0 & 0x8000000000L) != 0L)
 766  824
             return jjStartNfaWithStates_0(8, 39, 32);
 767  0
          break;
 768   
       case 105:
 769  0
          return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L);
 770   
       case 111:
 771  86
          return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L);
 772   
       case 116:
 773  256
          if ((active0 & 0x200000000000000L) != 0L)
 774  0
             return jjStartNfaWithStates_0(8, 57, 32);
 775  256
          return jjMoveStringLiteralDfa9_0(active0, 0x800000000L);
 776   
       default :
 777  280
          break;
 778   
    }
 779  280
    return jjStartNfa_0(7, active0, 0L);
 780   
 }
 781  342
 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
 782   
 {
 783  342
    if (((active0 &= old0)) == 0L)
 784  0
       return jjStartNfa_0(7, old0, 0L);
 785  342
    try { curChar = input_stream.readChar(); }
 786   
    catch(java.io.IOException e) {
 787  0
       jjStopStringLiteralDfa_0(8, active0, 0L);
 788  0
       return 9;
 789   
    }
 790  342
    switch(curChar)
 791   
    {
 792   
       case 102:
 793  86
          if ((active0 & 0x2000000000L) != 0L)
 794  86
             return jjStartNfaWithStates_0(9, 37, 32);
 795  0
          break;
 796   
       case 115:
 797  212
          if ((active0 & 0x800000000L) != 0L)
 798  212
             return jjStartNfaWithStates_0(9, 35, 32);
 799  0
          break;
 800   
       case 122:
 801  44
          return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L);
 802   
       default :
 803  0
          break;
 804   
    }
 805  0
    return jjStartNfa_0(8, active0, 0L);
 806   
 }
 807  44
 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
 808   
 {
 809  44
    if (((active0 &= old0)) == 0L)
 810  44
       return jjStartNfa_0(8, old0, 0L);
 811  0
    try { curChar = input_stream.readChar(); }
 812   
    catch(java.io.IOException e) {
 813  0
       jjStopStringLiteralDfa_0(9, active0, 0L);
 814  0
       return 10;
 815   
    }
 816  0
    switch(curChar)
 817   
    {
 818   
       case 101:
 819  0
          return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L);
 820   
       default :
 821  0
          break;
 822   
    }
 823  0
    return jjStartNfa_0(9, active0, 0L);
 824   
 }
 825  0
 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
 826   
 {
 827  0
    if (((active0 &= old0)) == 0L)
 828  0
       return jjStartNfa_0(9, old0, 0L);
 829  0
    try { curChar = input_stream.readChar(); }
 830   
    catch(java.io.IOException e) {
 831  0
       jjStopStringLiteralDfa_0(10, active0, 0L);
 832  0
       return 11;
 833   
    }
 834  0
    switch(curChar)
 835   
    {
 836   
       case 100:
 837  0
          if ((active0 & 0x20000000000000L) != 0L)
 838  0
             return jjStartNfaWithStates_0(11, 53, 32);
 839  0
          break;
 840   
       default :
 841  0
          break;
 842   
    }
 843  0
    return jjStartNfa_0(10, active0, 0L);
 844   
 }
 845  966758
 private final void jjCheckNAdd(int state)
 846   
 {
 847  966758
    if (jjrounds[state] != jjround)
 848   
    {
 849  966758
       jjstateSet[jjnewStateCnt++] = state;
 850  966758
       jjrounds[state] = jjround;
 851   
    }
 852   
 }
 853  794
 private final void jjAddStates(int start, int end)
 854   
 {
 855  794
    do {
 856  1880
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 857  1880
    } while (start++ != end);
 858   
 }
 859  1212
 private final void jjCheckNAddTwoStates(int state1, int state2)
 860   
 {
 861  1212
    jjCheckNAdd(state1);
 862  1212
    jjCheckNAdd(state2);
 863   
 }
 864  59480
 private final void jjCheckNAddStates(int start, int end)
 865   
 {
 866  59480
    do {
 867  183712
       jjCheckNAdd(jjnextStates[start]);
 868  183712
    } while (start++ != end);
 869   
 }
 870  0
 private final void jjCheckNAddStates(int start)
 871   
 {
 872  0
    jjCheckNAdd(jjnextStates[start]);
 873  0
    jjCheckNAdd(jjnextStates[start + 1]);
 874   
 }
 875   
 static final long[] jjbitVec0 = {
 876   
    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 877   
 };
 878   
 static final long[] jjbitVec2 = {
 879   
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 880   
 };
 881   
 static final long[] jjbitVec3 = {
 882   
    0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
 883   
 };
 884   
 static final long[] jjbitVec4 = {
 885   
    0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
 886   
 };
 887   
 static final long[] jjbitVec5 = {
 888   
    0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 889   
 };
 890   
 static final long[] jjbitVec6 = {
 891   
    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
 892   
 };
 893   
 static final long[] jjbitVec7 = {
 894   
    0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
 895   
 };
 896   
 static final long[] jjbitVec8 = {
 897   
    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
 898   
 };
 899  176928
 private final int jjMoveNfa_0(int startState, int curPos)
 900   
 {
 901  176928
    int[] nextStates;
 902  176928
    int startsAt = 0;
 903  176928
    jjnewStateCnt = 52;
 904  176928
    int i = 1;
 905  176928
    jjstateSet[0] = startState;
 906  176928
    int j, kind = 0x7fffffff;
 907  176928
    for (;;)
 908   
    {
 909  1022686
       if (++jjround == 0x7fffffff)
 910  0
          ReInitRounds();
 911  1022686
       if (curChar < 64)
 912   
       {
 913  180422
          long l = 1L << curChar;
 914  180422
          MatchLoop: do
 915   
          {
 916  221884
             switch(jjstateSet[--i])
 917   
             {
 918   
                case 3:
 919  4462
                   if ((0x3ff000000000000L & l) != 0L)
 920  1318
                      jjCheckNAddStates(0, 6);
 921  3144
                   else if (curChar == 36)
 922   
                   {
 923  0
                      if (kind > 73)
 924  0
                         kind = 73;
 925  0
                      jjCheckNAdd(32);
 926   
                   }
 927  3144
                   else if (curChar == 34)
 928  2642
                      jjCheckNAddStates(7, 9);
 929  502
                   else if (curChar == 39)
 930  502
                      jjAddStates(10, 11);
 931  0
                   else if (curChar == 46)
 932  0
                      jjCheckNAdd(8);
 933  0
                   else if (curChar == 47)
 934  0
                      jjstateSet[jjnewStateCnt++] = 2;
 935  4462
                   if ((0x3fe000000000000L & l) != 0L)
 936   
                   {
 937  606
                      if (kind > 65)
 938  606
                         kind = 65;
 939  606
                      jjCheckNAddTwoStates(5, 6);
 940   
                   }
 941  3856
                   else if (curChar == 48)
 942   
                   {
 943  712
                      if (kind > 65)
 944  712
                         kind = 65;
 945  712
                      jjCheckNAddStates(12, 14);
 946   
                   }
 947  4462
                   break;
 948   
                case 0:
 949  6248
                   if (curChar == 42)
 950  5574
                      jjstateSet[jjnewStateCnt++] = 1;
 951  6248
                   break;
 952   
                case 1:
 953  5574
                   if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
 954  5574
                      kind = 7;
 955  5574
                   break;
 956   
                case 2:
 957  34
                   if (curChar == 42)
 958  0
                      jjstateSet[jjnewStateCnt++] = 0;
 959  34
                   break;
 960   
                case 4:
 961  0
                   if ((0x3fe000000000000L & l) == 0L)
 962  0
                      break;
 963  0
                   if (kind > 65)
 964  0
                      kind = 65;
 965  0
                   jjCheckNAddTwoStates(5, 6);
 966  0
                   break;
 967   
                case 5:
 968  800
                   if ((0x3ff000000000000L & l) == 0L)
 969  598
                      break;
 970  202
                   if (kind > 65)
 971  202
                      kind = 65;
 972  202
                   jjCheckNAddTwoStates(5, 6);
 973  202
                   break;
 974   
                case 7:
 975  0
                   if (curChar == 46)
 976  0
                      jjCheckNAdd(8);
 977  0
                   break;
 978   
                case 8:
 979  248
                   if ((0x3ff000000000000L & l) == 0L)
 980  248
                      break;
 981  0
                   if (kind > 69)
 982  0
                      kind = 69;
 983  0
                   jjCheckNAddStates(15, 17);
 984  0
                   break;
 985   
                case 10:
 986  0
                   if ((0x280000000000L & l) != 0L)
 987  0
                      jjCheckNAdd(11);
 988  0
                   break;
 989   
                case 11:
 990  0
                   if ((0x3ff000000000000L & l) == 0L)
 991  0
                      break;
 992  0
                   if (kind > 69)
 993  0
                      kind = 69;
 994  0
                   jjCheckNAddTwoStates(11, 12);
 995  0
                   break;
 996   
                case 13:
 997  0
                   if (curChar == 39)
 998  0
                      jjAddStates(10, 11);
 999  0
                   break;
 1000   
                case 14:
 1001  454
                   if ((0xffffff7fffffdbffL & l) != 0L)
 1002  454
                      jjCheckNAdd(15);
 1003  454
                   break;
 1004   
                case 15:
 1005  502
                   if (curChar == 39 && kind > 71)
 1006  502
                      kind = 71;
 1007  502
                   break;
 1008   
                case 17:
 1009  0
                   if ((0x8400000000L & l) != 0L)
 1010  0
                      jjCheckNAdd(15);
 1011  0
                   break;
 1012   
                case 18:
 1013  0
                   if ((0xff000000000000L & l) != 0L)
 1014  0
                      jjCheckNAddTwoStates(19, 15);
 1015  0
                   break;
 1016   
                case 19:
 1017  0
                   if ((0xff000000000000L & l) != 0L)
 1018  0
                      jjCheckNAdd(15);
 1019  0
                   break;
 1020   
                case 20:
 1021  0
                   if ((0xf000000000000L & l) != 0L)
 1022  0
                      jjstateSet[jjnewStateCnt++] = 21;
 1023  0
                   break;
 1024   
                case 21:
 1025  0
                   if ((0xff000000000000L & l) != 0L)
 1026  0
                      jjCheckNAdd(19);
 1027  0
                   break;
 1028   
                case 22:
 1029  0
                   if (curChar == 34)
 1030  0
                      jjCheckNAddStates(7, 9);
 1031  0
                   break;
 1032   
                case 23:
 1033  14008
                   if ((0xfffffffbffffdbffL & l) != 0L)
 1034  11366
                      jjCheckNAddStates(7, 9);
 1035  14008
                   break;
 1036   
                case 25:
 1037  128
                   if ((0x8400000000L & l) != 0L)
 1038  128
                      jjCheckNAddStates(7, 9);
 1039  128
                   break;
 1040   
                case 26:
 1041  14008
                   if (curChar == 34 && kind > 72)
 1042  2642
                      kind = 72;
 1043  14008
                   break;
 1044   
                case 27:
 1045  128
                   if ((0xff000000000000L & l) != 0L)
 1046  0
                      jjCheckNAddStates(18, 21);
 1047  128
                   break;
 1048   
                case 28:
 1049  0
                   if ((0xff000000000000L & l) != 0L)
 1050  0
                      jjCheckNAddStates(7, 9);
 1051  0
                   break;
 1052   
                case 29:
 1053  128
                   if ((0xf000000000000L & l) != 0L)
 1054  0
                      jjstateSet[jjnewStateCnt++] = 30;
 1055  128
                   break;
 1056   
                case 30:
 1057  0
                   if ((0xff000000000000L & l) != 0L)
 1058  0
                      jjCheckNAdd(28);
 1059  0
                   break;
 1060   
                case 31:
 1061  0
                   if (curChar != 36)
 1062  0
                      break;
 1063  0
                   if (kind > 73)
 1064  0
                      kind = 73;
 1065  0
                   jjCheckNAdd(32);
 1066  0
                   break;
 1067   
                case 32:
 1068  134812
                   if ((0x3ff001000000000L & l) == 0L)
 1069  134812
                      break;
 1070  0
                   if (kind > 73)
 1071  0
                      kind = 73;
 1072  0
                   jjCheckNAdd(32);
 1073  0
                   break;
 1074   
                case 33:
 1075  0
                   if ((0x3ff000000000000L & l) != 0L)
 1076  0
                      jjCheckNAddStates(0, 6);
 1077  0
                   break;
 1078   
                case 34:
 1079  1504
                   if ((0x3ff000000000000L & l) != 0L)
 1080  202
                      jjCheckNAddTwoStates(34, 35);
 1081  1504
                   break;
 1082   
                case 35:
 1083  1504
                   if (curChar != 46)
 1084  1504
                      break;
 1085  0
                   if (kind > 69)
 1086  0
                      kind = 69;
 1087  0
                   jjCheckNAddStates(22, 24);
 1088  0
                   break;
 1089   
                case 36:
 1090  0
                   if ((0x3ff000000000000L & l) == 0L)
 1091  0
                      break;
 1092  0
                   if (kind > 69)
 1093  0
                      kind = 69;
 1094  0
                   jjCheckNAddStates(22, 24);
 1095  0
                   break;
 1096   
                case 38:
 1097  0
                   if ((0x280000000000L & l) != 0L)
 1098  0
                      jjCheckNAdd(39);
 1099  0
                   break;
 1100   
                case 39:
 1101  0
                   if ((0x3ff000000000000L & l) == 0L)
 1102  0
                      break;
 1103  0
                   if (kind > 69)
 1104  0
                      kind = 69;
 1105  0
                   jjCheckNAddTwoStates(39, 12);
 1106  0
                   break;
 1107   
                case 40:
 1108  1504
                   if ((0x3ff000000000000L & l) != 0L)
 1109  202
                      jjCheckNAddTwoStates(40, 41);
 1110  1504
                   break;
 1111   
                case 42:
 1112  0
                   if ((0x280000000000L & l) != 0L)
 1113  0
                      jjCheckNAdd(43);
 1114  0
                   break;
 1115   
                case 43:
 1116  0
                   if ((0x3ff000000000000L & l) == 0L)
 1117  0
                      break;
 1118  0
                   if (kind > 69)
 1119  0
                      kind = 69;
 1120  0
                   jjCheckNAddTwoStates(43, 12);
 1121  0
                   break;
 1122   
                case 44:
 1123  1504
                   if ((0x3ff000000000000L & l) != 0L)
 1124  202
                      jjCheckNAddStates(25, 27);
 1125  1504
                   break;
 1126   
                case 46:
 1127  0
                   if ((0x280000000000L & l) != 0L)
 1128  0
                      jjCheckNAdd(47);
 1129  0
                   break;
 1130   
                case 47:
 1131  0
                   if ((0x3ff000000000000L & l) != 0L)
 1132  0
                      jjCheckNAddTwoStates(47, 12);
 1133  0
                   break;
 1134   
                case 48:
 1135  0
                   if (curChar != 48)
 1136  0
                      break;
 1137  0
                   if (kind > 65)
 1138  0
                      kind = 65;
 1139  0
                   jjCheckNAddStates(12, 14);
 1140  0
                   break;
 1141   
                case 50:
 1142  0
                   if ((0x3ff000000000000L & l) == 0L)
 1143  0
                      break;
 1144  0
                   if (kind > 65)
 1145  0
                      kind = 65;
 1146  0
                   jjCheckNAddTwoStates(50, 6);
 1147  0
                   break;
 1148   
                case 51:
 1149  704
                   if ((0xff000000000000L & l) == 0L)
 1150  704
                      break;
 1151  0
                   if (kind > 65)
 1152  0
                      kind = 65;
 1153  0
                   jjCheckNAddTwoStates(51, 6);
 1154  0
                   break;
 1155  33630
                default : break;
 1156   
             }
 1157  221884
          } while(i != startsAt);
 1158   
       }
 1159  842264
       else if (curChar < 128)
 1160   
       {
 1161  842264
          long l = 1L << (curChar & 077);
 1162  842264
          MatchLoop: do
 1163   
          {
 1164  929256
             switch(jjstateSet[--i])
 1165   
             {
 1166   
                case 3:
 1167   
                case 32:
 1168  780620
                   if ((0x7fffffe87fffffeL & l) == 0L)
 1169  500
                      break;
 1170  780120
                   if (kind > 73)
 1171  780120
                      kind = 73;
 1172  780120
                   jjCheckNAdd(32);
 1173  780120
                   break;
 1174   
                case 1:
 1175  0
                   if (kind > 7)
 1176  0
                      kind = 7;
 1177  0
                   break;
 1178   
                case 6:
 1179  16
                   if ((0x100000001000L & l) != 0L && kind > 65)
 1180  0
                      kind = 65;
 1181  16
                   break;
 1182   
                case 9:
 1183  0
                   if ((0x2000000020L & l) != 0L)
 1184  0
                      jjAddStates(28, 29);
 1185  0
                   break;
 1186   
                case 12:
 1187  16
                   if ((0x5000000050L & l) != 0L && kind > 69)
 1188  0
                      kind = 69;
 1189  16
                   break;
 1190   
                case 14:
 1191  48
                   if ((0xffffffffefffffffL & l) != 0L)
 1192  36
                      jjCheckNAdd(15);
 1193  48
                   break;
 1194   
                case 16:
 1195  48
                   if (curChar == 92)
 1196  12
                      jjAddStates(30, 32);
 1197  48
                   break;
 1198   
                case 17:
 1199  12
                   if ((0x14404410000000L & l) != 0L)
 1200  12
                      jjCheckNAdd(15);
 1201  12
                   break;
 1202   
                case 23:
 1203  43240
                   if ((0xffffffffefffffffL & l) != 0L)
 1204  42960
                      jjCheckNAddStates(7, 9);
 1205  43240
                   break;
 1206   
                case 24:
 1207  43240
                   if (curChar == 92)
 1208  280
                      jjAddStates(33, 35);
 1209  43240
                   break;
 1210   
                case 25:
 1211  152
                   if ((0x14404410000000L & l) != 0L)
 1212  152
                      jjCheckNAddStates(7, 9);
 1213  152
                   break;
 1214   
                case 37:
 1215  0
                   if ((0x2000000020L & l) != 0L)
 1216  0
                      jjAddStates(36, 37);
 1217  0
                   break;
 1218   
                case 41:
 1219  16
                   if ((0x2000000020L & l) != 0L)
 1220  0
                      jjAddStates(38, 39);
 1221  16
                   break;
 1222   
                case 45:
 1223  16
                   if ((0x2000000020L & l) != 0L)
 1224  0
                      jjAddStates(40, 41);
 1225  16
                   break;
 1226   
                case 49:
 1227  8
                   if ((0x100000001000000L & l) != 0L)
 1228  0
                      jjCheckNAdd(50);
 1229  8
                   break;
 1230   
                case 50:
 1231  0
                   if ((0x7e0000007eL & l) == 0L)
 1232  0
                      break;
 1233  0
                   if (kind > 65)
 1234  0
                      kind = 65;
 1235  0
                   jjCheckNAddTwoStates(50, 6);
 1236  0
                   break;
 1237  61824
                default : break;
 1238   
             }
 1239  929256
          } while(i != startsAt);
 1240   
       }
 1241   
       else
 1242   
       {
 1243  0
          int hiByte = (int)(curChar >> 8);
 1244  0
          int i1 = hiByte >> 6;
 1245  0
          long l1 = 1L << (hiByte & 077);
 1246  0
          int i2 = (curChar & 0xff) >> 6;
 1247  0
          long l2 = 1L << (curChar & 077);
 1248  0
          MatchLoop: do
 1249   
          {
 1250  0
             switch(jjstateSet[--i])
 1251   
             {
 1252   
                case 3:
 1253   
                case 32:
 1254  0
                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
 1255  0
                      break;
 1256  0
                   if (kind > 73)
 1257  0
                      kind = 73;
 1258  0
                   jjCheckNAdd(32);
 1259  0
                   break;
 1260   
                case 1:
 1261  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
 1262  0
                      kind = 7;
 1263  0
                   break;
 1264   
                case 14:
 1265  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1266  0
                      jjstateSet[jjnewStateCnt++] = 15;
 1267  0
                   break;
 1268   
                case 23:
 1269  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 1270  0
                      jjAddStates(7, 9);
 1271  0
                   break;
 1272  0
                default : break;
 1273   
             }
 1274  0
          } while(i != startsAt);
 1275   
       }
 1276  1022686
       if (kind != 0x7fffffff)
 1277   
       {
 1278  790358
          jjmatchedKind = kind;
 1279  790358
          jjmatchedPos = curPos;
 1280  790358
          kind = 0x7fffffff;
 1281   
       }
 1282  1022686
       ++curPos;
 1283  ?
       if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt)))
 1284  176928
          return curPos;
 1285  845758
       try { curChar = input_stream.readChar(); }
 1286  0
       catch(java.io.IOException e) { return curPos; }
 1287   
    }
 1288   
 }
 1289  74194
 private final int jjMoveStringLiteralDfa0_3()
 1290   
 {
 1291  74194
    switch(curChar)
 1292   
    {
 1293   
       case 42:
 1294  2416
          return jjMoveStringLiteralDfa1_3(0x800L);
 1295   
       default :
 1296  71778
          return 1;
 1297   
    }
 1298   
 }
 1299  2416
 private final int jjMoveStringLiteralDfa1_3(long active0)
 1300   
 {
 1301  2416
    try { curChar = input_stream.readChar(); }
 1302   
    catch(java.io.IOException e) {
 1303  0
       return 1;
 1304   
    }
 1305  2416
    switch(curChar)
 1306   
    {
 1307   
       case 47:
 1308  674
          if ((active0 & 0x800L) != 0L)
 1309  674
             return jjStopAtPos(1, 11);
 1310  0
          break;
 1311   
       default :
 1312  1742
          return 2;
 1313   
    }
 1314  0
    return 2;
 1315   
 }
 1316  164862
 private final int jjMoveStringLiteralDfa0_1()
 1317   
 {
 1318  164862
    return jjMoveNfa_1(0, 0);
 1319   
 }
 1320  164862
 private final int jjMoveNfa_1(int startState, int curPos)
 1321   
 {
 1322  164862
    int[] nextStates;
 1323  164862
    int startsAt = 0;
 1324  164862
    jjnewStateCnt = 3;
 1325  164862
    int i = 1;
 1326  164862
    jjstateSet[0] = startState;
 1327  164862
    int j, kind = 0x7fffffff;
 1328  164862
    for (;;)
 1329   
    {
 1330  168186
       if (++jjround == 0x7fffffff)
 1331  0
          ReInitRounds();
 1332  168186
       if (curChar < 64)
 1333   
       {
 1334  42028
          long l = 1L << curChar;
 1335  42028
          MatchLoop: do
 1336   
          {
 1337  42028
             switch(jjstateSet[--i])
 1338   
             {
 1339   
                case 0:
 1340  38704
                   if ((0x2400L & l) != 0L)
 1341   
                   {
 1342  3324
                      if (kind > 9)
 1343  3324
                         kind = 9;
 1344   
                   }
 1345  38704
                   if (curChar == 13)
 1346  3324
                      jjstateSet[jjnewStateCnt++] = 1;
 1347  38704
                   break;
 1348   
                case 1:
 1349  3324
                   if (curChar == 10 && kind > 9)
 1350  3324
                      kind = 9;
 1351  3324
                   break;
 1352   
                case 2:
 1353  0
                   if (curChar == 13)
 1354  0
                      jjstateSet[jjnewStateCnt++] = 1;
 1355  0
                   break;
 1356  0
                default : break;
 1357   
             }
 1358  42028
          } while(i != startsAt);
 1359   
       }
 1360  126158
       else if (curChar < 128)
 1361   
       {
 1362  126158
          long l = 1L << (curChar & 077);
 1363  126158
          MatchLoop: do
 1364   
          {
 1365  126158
             switch(jjstateSet[--i])
 1366   
             {
 1367  126158
                default : break;
 1368   
             }
 1369  126158
          } while(i != startsAt);
 1370   
       }
 1371   
       else
 1372   
       {
 1373  0
          int hiByte = (int)(curChar >> 8);
 1374  0
          int i1 = hiByte >> 6;
 1375  0
          long l1 = 1L << (hiByte & 077);
 1376  0
          int i2 = (curChar & 0xff) >> 6;
 1377  0
          long l2 = 1L << (curChar & 077);
 1378  0
          MatchLoop: do
 1379   
          {
 1380  0
             switch(jjstateSet[--i])
 1381   
             {
 1382  0
                default : break;
 1383   
             }
 1384  0
          } while(i != startsAt);
 1385   
       }
 1386  168186
       if (kind != 0x7fffffff)
 1387   
       {
 1388  6648
          jjmatchedKind = kind;
 1389  6648
          jjmatchedPos = curPos;
 1390  6648
          kind = 0x7fffffff;
 1391   
       }
 1392  168186
       ++curPos;
 1393  ?
       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
 1394  164862
          return curPos;
 1395  3324
       try { curChar = input_stream.readChar(); }
 1396  0
       catch(java.io.IOException e) { return curPos; }
 1397   
    }
 1398   
 }
 1399  863210
 private final int jjMoveStringLiteralDfa0_2()
 1400   
 {
 1401  863210
    switch(curChar)
 1402   
    {
 1403   
       case 42:
 1404  27332
          return jjMoveStringLiteralDfa1_2(0x400L);
 1405   
       default :
 1406  835878
          return 1;
 1407   
    }
 1408   
 }
 1409  27332
 private final int jjMoveStringLiteralDfa1_2(long active0)
 1410   
 {
 1411  27332
    try { curChar = input_stream.readChar(); }
 1412   
    catch(java.io.IOException e) {
 1413  0
       return 1;
 1414   
    }
 1415  27332
    switch(curChar)
 1416   
    {
 1417   
       case 47:
 1418  5574
          if ((active0 & 0x400L) != 0L)
 1419  5574
             return jjStopAtPos(1, 10);
 1420  0
          break;
 1421   
       default :
 1422  21758
          return 2;
 1423   
    }
 1424  0
    return 2;
 1425   
 }
 1426   
 static final int[] jjnextStates = {
 1427   
    34, 35, 40, 41, 44, 45, 12, 23, 24, 26, 14, 16, 49, 51, 6, 8, 
 1428   
    9, 12, 23, 24, 28, 26, 36, 37, 12, 44, 45, 12, 10, 11, 17, 18, 
 1429   
    20, 25, 27, 29, 38, 39, 42, 43, 46, 47, 
 1430   
 };
 1431  0
 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
 1432   
 {
 1433  0
    switch(hiByte)
 1434   
    {
 1435   
       case 0:
 1436  0
          return ((jjbitVec2[i2] & l2) != 0L);
 1437   
       default : 
 1438  0
          if ((jjbitVec0[i1] & l1) != 0L)
 1439  0
             return true;
 1440  0
          return false;
 1441   
    }
 1442   
 }
 1443  0
 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
 1444   
 {
 1445  0
    switch(hiByte)
 1446   
    {
 1447   
       case 0:
 1448  0
          return ((jjbitVec4[i2] & l2) != 0L);
 1449   
       case 48:
 1450  0
          return ((jjbitVec5[i2] & l2) != 0L);
 1451   
       case 49:
 1452  0
          return ((jjbitVec6[i2] & l2) != 0L);
 1453   
       case 51:
 1454  0
          return ((jjbitVec7[i2] & l2) != 0L);
 1455   
       case 61:
 1456  0
          return ((jjbitVec8[i2] & l2) != 0L);
 1457   
       default : 
 1458  0
          if ((jjbitVec3[i1] & l1) != 0L)
 1459  0
             return true;
 1460  0
          return false;
 1461   
    }
 1462   
 }
 1463   
 public static final String[] jjstrLiteralImages = {
 1464   
 "", null, null, null, null, null, null, null, null, null, null, null, null, 
 1465   
 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145", 
 1466   
 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", 
 1467   
 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", 
 1468   
 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145", 
 1469   
 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154", 
 1470   
 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", 
 1471   
 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", 
 1472   
 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", 
 1473   
 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145", 
 1474   
 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 
 1475   
 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162", 
 1476   
 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", 
 1477   
 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164", 
 1478   
 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", 
 1479   
 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", "\141\163\163\145\162\164", null, null, 
 1480   
 null, null, null, null, null, null, null, null, null, "\50", "\51", "\173", "\175", 
 1481   
 "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74", "\41", "\176", "\77", "\72", 
 1482   
 "\75\75", "\74\75", "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", 
 1483   
 "\55", "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76", 
 1484   
 "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", 
 1485   
 "\74\74\75", "\76\76\75", "\76\76\76\75", };
 1486   
 public static final String[] lexStateNames = {
 1487   
    "DEFAULT", 
 1488   
    "IN_SINGLE_LINE_COMMENT", 
 1489   
    "IN_FORMAL_COMMENT", 
 1490   
    "IN_MULTI_LINE_COMMENT", 
 1491   
 };
 1492   
 public static final int[] jjnewLexState = {
 1493   
    -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 1494   
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 1495   
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 1496   
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 1497   
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 1498   
 };
 1499   
 static final long[] jjtoToken = {
 1500   
    0xffffffffffffe001L, 0x3fffffffffff3a3L, 
 1501   
 };
 1502   
 static final long[] jjtoSkip = {
 1503   
    0xe3eL, 0x0L, 
 1504   
 };
 1505   
 static final long[] jjtoSpecial = {
 1506   
    0xe3eL, 0x0L, 
 1507   
 };
 1508   
 static final long[] jjtoMore = {
 1509   
    0x11c0L, 0x0L, 
 1510   
 };
 1511   
 private JavaCharStream input_stream;
 1512   
 private final int[] jjrounds = new int[52];
 1513   
 private final int[] jjstateSet = new int[104];
 1514   
 StringBuffer image;
 1515   
 int jjimageLen;
 1516   
 int lengthOfMatch;
 1517   
 protected char curChar;
 1518  672
 public SimpleParserTokenManager(JavaCharStream stream)
 1519   
 {
 1520  672
    if (JavaCharStream.staticFlag)
 1521  0
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 1522  672
    input_stream = stream;
 1523   
 }
 1524  0
 public SimpleParserTokenManager(JavaCharStream stream, int lexState)
 1525   
 {
 1526  0
    this(stream);
 1527  0
    SwitchTo(lexState);
 1528   
 }
 1529  672
 public void ReInit(JavaCharStream stream)
 1530   
 {
 1531  672
    jjmatchedPos = jjnewStateCnt = 0;
 1532  672
    curLexState = defaultLexState;
 1533  672
    input_stream = stream;
 1534  672
    ReInitRounds();
 1535   
 }
 1536  672
 private final void ReInitRounds()
 1537   
 {
 1538  672
    int i;
 1539  672
    jjround = 0x80000001;
 1540  672
    for (i = 52; i-- > 0;)
 1541  34944
       jjrounds[i] = 0x80000000;
 1542   
 }
 1543  0
 public void ReInit(JavaCharStream stream, int lexState)
 1544   
 {
 1545  0
    ReInit(stream);
 1546  0
    SwitchTo(lexState);
 1547   
 }
 1548  0
 public void SwitchTo(int lexState)
 1549   
 {
 1550  0
    if (lexState >= 4 || lexState < 0)
 1551  0
       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 1552   
    else
 1553  0
       curLexState = lexState;
 1554   
 }
 1555   
 
 1556  778924
 private final Token jjFillToken()
 1557   
 {
 1558  778924
    Token t = Token.newToken(jjmatchedKind);
 1559  778924
    t.kind = jjmatchedKind;
 1560  778924
    String im = jjstrLiteralImages[jjmatchedKind];
 1561  778924
    t.image = (im == null) ? input_stream.GetImage() : im;
 1562  778924
    t.beginLine = input_stream.getBeginLine();
 1563  778924
    t.beginColumn = input_stream.getBeginColumn();
 1564  778924
    t.endLine = input_stream.getEndLine();
 1565  778924
    t.endColumn = input_stream.getEndColumn();
 1566  778924
    return t;
 1567   
 }
 1568   
 
 1569   
 int curLexState = 0;
 1570   
 int defaultLexState = 0;
 1571   
 int jjnewStateCnt;
 1572   
 int jjround;
 1573   
 int jjmatchedPos;
 1574   
 int jjmatchedKind;
 1575   
 
 1576  303384
 public final Token getNextToken() 
 1577   
 {
 1578  303384
   int kind;
 1579  303384
   Token specialToken = null;
 1580  303384
   Token matchedToken;
 1581  303384
   int curPos = 0;
 1582   
 
 1583  303384
   EOFLoop :
 1584   
   for (;;)
 1585   
   {   
 1586  778924
    try   
 1587   
    {     
 1588  778924
       curChar = input_stream.BeginToken();
 1589   
    }     
 1590   
    catch(java.io.IOException e)
 1591   
    {        
 1592  2016
       jjmatchedKind = 0;
 1593  2016
       matchedToken = jjFillToken();
 1594  2016
       matchedToken.specialToken = specialToken;
 1595  2016
       return matchedToken;
 1596   
    }
 1597  776908
    image = null;
 1598  776908
    jjimageLen = 0;
 1599   
 
 1600  776908
    for (;;)
 1601   
    {
 1602  1879174
      switch(curLexState)
 1603   
      {
 1604   
        case 0:
 1605  776908
          jjmatchedKind = 0x7fffffff;
 1606  776908
          jjmatchedPos = 0;
 1607  776908
          curPos = jjMoveStringLiteralDfa0_0();
 1608  776908
          break;
 1609   
        case 1:
 1610  164862
          jjmatchedKind = 0x7fffffff;
 1611  164862
          jjmatchedPos = 0;
 1612  164862
          curPos = jjMoveStringLiteralDfa0_1();
 1613  164862
          if (jjmatchedPos == 0 && jjmatchedKind > 12)
 1614   
          {
 1615  161538
             jjmatchedKind = 12;
 1616   
          }
 1617  164862
          break;
 1618   
        case 2:
 1619  863210
          jjmatchedKind = 0x7fffffff;
 1620  863210
          jjmatchedPos = 0;
 1621  863210
          curPos = jjMoveStringLiteralDfa0_2();
 1622  863210
          if (jjmatchedPos == 0 && jjmatchedKind > 12)
 1623   
          {
 1624  857636
             jjmatchedKind = 12;
 1625   
          }
 1626  863210
          break;
 1627   
        case 3:
 1628  74194
          jjmatchedKind = 0x7fffffff;
 1629  74194
          jjmatchedPos = 0;
 1630  74194
          curPos = jjMoveStringLiteralDfa0_3();
 1631  74194
          if (jjmatchedPos == 0 && jjmatchedKind > 12)
 1632   
          {
 1633  73520
             jjmatchedKind = 12;
 1634   
          }
 1635  74194
          break;
 1636   
      }
 1637  1879174
      if (jjmatchedKind != 0x7fffffff)
 1638   
      {
 1639  1879174
         if (jjmatchedPos + 1 < curPos)
 1640  191710
            input_stream.backup(curPos - jjmatchedPos - 1);
 1641  1879174
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1642   
         {
 1643  301368
            matchedToken = jjFillToken();
 1644  301368
            matchedToken.specialToken = specialToken;
 1645  301368
        if (jjnewLexState[jjmatchedKind] != -1)
 1646  0
          curLexState = jjnewLexState[jjmatchedKind];
 1647  301368
            return matchedToken;
 1648   
         }
 1649  1577806
         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1650   
         {
 1651  475540
            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1652   
            {
 1653  475540
               matchedToken = jjFillToken();
 1654  475540
               if (specialToken == null)
 1655  183628
                  specialToken = matchedToken;
 1656   
               else
 1657   
               {
 1658  291912
                  matchedToken.specialToken = specialToken;
 1659  291912
                  specialToken = (specialToken.next = matchedToken);
 1660   
               }
 1661  475540
               SkipLexicalActions(matchedToken);
 1662   
            }
 1663   
            else 
 1664  0
               SkipLexicalActions(null);
 1665  475540
          if (jjnewLexState[jjmatchedKind] != -1)
 1666  9572
            curLexState = jjnewLexState[jjmatchedKind];
 1667  475540
            continue EOFLoop;
 1668   
         }
 1669  1102266
         MoreLexicalActions();
 1670  1102266
       if (jjnewLexState[jjmatchedKind] != -1)
 1671  9572
         curLexState = jjnewLexState[jjmatchedKind];
 1672  1102266
         curPos = 0;
 1673  1102266
         jjmatchedKind = 0x7fffffff;
 1674  1102266
         try {
 1675  1102266
            curChar = input_stream.readChar();
 1676  1102266
            continue;
 1677   
         }
 1678   
         catch (java.io.IOException e1) { }
 1679   
      }
 1680  0
      int error_line = input_stream.getEndLine();
 1681  0
      int error_column = input_stream.getEndColumn();
 1682  0
      String error_after = null;
 1683  0
      boolean EOFSeen = false;
 1684  0
      try { input_stream.readChar(); input_stream.backup(1); }
 1685   
      catch (java.io.IOException e1) {
 1686  0
         EOFSeen = true;
 1687  0
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 1688  0
         if (curChar == '\n' || curChar == '\r') {
 1689  0
            error_line++;
 1690  0
            error_column = 0;
 1691   
         }
 1692   
         else
 1693  0
            error_column++;
 1694   
      }
 1695  0
      if (!EOFSeen) {
 1696  0
         input_stream.backup(1);
 1697  0
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 1698   
      }
 1699  0
      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 1700   
    }
 1701   
   }
 1702   
 }
 1703   
 
 1704  475540
 final void SkipLexicalActions(Token matchedToken)
 1705   
 {
 1706  475540
    switch(jjmatchedKind)
 1707   
    {
 1708   
       default :
 1709  475540
          break;
 1710   
    }
 1711   
 }
 1712  1102266
 final void MoreLexicalActions()
 1713   
 {
 1714  1102266
    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
 1715  1102266
    switch(jjmatchedKind)
 1716   
    {
 1717   
       case 7 :
 1718  5574
          if (image == null)
 1719  5574
               image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
 1720   
          else
 1721  0
             image.append(input_stream.GetSuffix(jjimageLen));
 1722  5574
          jjimageLen = 0;
 1723  5574
                    input_stream.backup(1);
 1724  5574
          break;
 1725   
       default : 
 1726  1096692
          break;
 1727   
    }
 1728   
 }
 1729   
 }
 1730