Clover coverage report - XJavaDoc - 1.1
Coverage timestamp: Mon Oct 4 2004 23:49:51 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% 60% 80.5% 56.4%
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  30263
 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
 13   
 {
 14  30263
    switch (pos)
 15   
    {
 16   
       case 0:
 17  22212
          if ((active0 & 0x140L) != 0L || (active1 & 0x4008000000000L) != 0L)
 18  17
             return 2;
 19  22195
          if ((active1 & 0x100000L) != 0L)
 20  0
             return 8;
 21  22195
          if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L)
 22   
          {
 23  15676
             jjmatchedKind = 73;
 24  15676
             return 32;
 25   
          }
 26  6519
          return -1;
 27   
       case 1:
 28  4274
          if ((active0 & 0x100L) != 0L)
 29  0
             return 0;
 30  4274
          if ((active0 & 0xfffffffbfcffe000L) != 0L || (active1 & 0x1L) != 0L)
 31   
          {
 32  3833
             if (jjmatchedPos != 1)
 33   
             {
 34  3833
                jjmatchedKind = 73;
 35  3833
                jjmatchedPos = 1;
 36   
             }
 37  3833
             return 32;
 38   
          }
 39  441
          if ((active0 & 0x403000000L) != 0L)
 40  441
             return 32;
 41  0
          return -1;
 42   
       case 2:
 43  1619
          if ((active0 & 0xf7fffb3afeffe000L) != 0L || (active1 & 0x1L) != 0L)
 44   
          {
 45  927
             if (jjmatchedPos != 2)
 46   
             {
 47  927
                jjmatchedKind = 73;
 48  927
                jjmatchedPos = 2;
 49   
             }
 50  927
             return 32;
 51   
          }
 52  692
          if ((active0 & 0x80004c100000000L) != 0L)
 53  692
             return 32;
 54  0
          return -1;
 55   
       case 3:
 56  286
          if ((active0 & 0xe3bff2b8faf4e000L) != 0L || (active1 & 0x1L) != 0L)
 57   
          {
 58  286
             jjmatchedKind = 73;
 59  286
             jjmatchedPos = 3;
 60  286
             return 32;
 61   
          }
 62  0
          if ((active0 & 0x14400902040b0000L) != 0L)
 63  0
             return 32;
 64  0
          return -1;
 65   
       case 4:
 66  1688
          if ((active0 & 0xa235f2b80ac06000L) != 0L || (active1 & 0x1L) != 0L)
 67   
          {
 68  22
             if (jjmatchedPos != 4)
 69   
             {
 70  22
                jjmatchedKind = 73;
 71  22
                jjmatchedPos = 4;
 72   
             }
 73  22
             return 32;
 74   
          }
 75  1666
          if ((active0 & 0x418a0000f0348000L) != 0L)
 76  1666
             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  22
          if ((active0 & 0xa22040a800402000L) != 0L)
 90   
          {
 91  22
             jjmatchedKind = 73;
 92  22
             jjmatchedPos = 6;
 93  22
             return 32;
 94   
          }
 95  0
          if ((active0 & 0x300048804000L) != 0L)
 96  0
             return 32;
 97  0
          return -1;
 98   
       case 7:
 99  140
          if ((active0 & 0x22040a800000000L) != 0L)
 100   
          {
 101  140
             jjmatchedKind = 73;
 102  140
             jjmatchedPos = 7;
 103  140
             return 32;
 104   
          }
 105  0
          if ((active0 & 0xa000000000402000L) != 0L)
 106  0
             return 32;
 107  0
          return -1;
 108   
       case 8:
 109  22
          if ((active0 & 0x20002800000000L) != 0L)
 110   
          {
 111  22
             jjmatchedKind = 73;
 112  22
             jjmatchedPos = 8;
 113  22
             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  30263
 private final int jjStartNfa_0(int pos, long active0, long active1)
 141   
 {
 142  30263
    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
 143   
 }
 144  262170
 private final int jjStopAtPos(int pos, int kind)
 145   
 {
 146  262170
    jjmatchedKind = kind;
 147  262170
    jjmatchedPos = pos;
 148  262170
    return pos + 1;
 149   
 }
 150  32688
 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
 151   
 {
 152  32688
    jjmatchedKind = kind;
 153  32688
    jjmatchedPos = pos;
 154  32688
    try { curChar = input_stream.readChar(); }
 155  0
    catch(java.io.IOException e) { return pos + 1; }
 156  32688
    return jjMoveNfa_0(state, pos + 1);
 157   
 }
 158  347510
 private final int jjMoveStringLiteralDfa0_0()
 159   
 {
 160  347510
    switch(curChar)
 161   
    {
 162   
       case 9:
 163  63642
          return jjStopAtPos(0, 2);
 164   
       case 10:
 165  41280
          return jjStopAtPos(0, 3);
 166   
       case 12:
 167  0
          return jjStopAtPos(0, 5);
 168   
       case 13:
 169  0
          return jjStopAtPos(0, 4);
 170   
       case 32:
 171  87118
          return jjStopAtPos(0, 1);
 172   
       case 33:
 173  1192
          jjmatchedKind = 88;
 174  1192
          return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
 175   
       case 37:
 176  0
          jjmatchedKind = 107;
 177  0
          return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
 178   
       case 38:
 179  297
          jjmatchedKind = 104;
 180  297
          return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L);
 181   
       case 40:
 182  17470
          return jjStopAtPos(0, 76);
 183   
       case 41:
 184  17470
          return jjStopAtPos(0, 77);
 185   
       case 42:
 186  168
          jjmatchedKind = 102;
 187  168
          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
 188   
       case 43:
 189  1246
          jjmatchedKind = 100;
 190  1246
          return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L);
 191   
       case 44:
 192  2085
          return jjStopAtPos(0, 83);
 193   
       case 45:
 194  86
          jjmatchedKind = 101;
 195  86
          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000800000000L);
 196   
       case 46:
 197  8917
          return jjStartNfaWithStates_0(0, 84, 8);
 198   
       case 47:
 199  4803
          jjmatchedKind = 103;
 200  4803
          return jjMoveStringLiteralDfa1_0(0x140L, 0x4000000000000L);
 201   
       case 58:
 202  158
          return jjStopAtPos(0, 91);
 203   
       case 59:
 204  12955
          return jjStopAtPos(0, 82);
 205   
       case 60:
 206  160
          jjmatchedKind = 87;
 207  160
          return jjMoveStringLiteralDfa1_0(0x0L, 0x80100020000000L);
 208   
       case 61:
 209  5424
          jjmatchedKind = 85;
 210  5424
          return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
 211   
       case 62:
 212  32
          jjmatchedKind = 86;
 213  32
          return jjMoveStringLiteralDfa1_0(0x0L, 0x300600040000000L);
 214   
       case 63:
 215  142
          return jjStopAtPos(0, 90);
 216   
       case 91:
 217  177
          return jjStopAtPos(0, 80);
 218   
       case 93:
 219  177
          return jjStopAtPos(0, 81);
 220   
       case 94:
 221  0
          jjmatchedKind = 106;
 222  0
          return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
 223   
       case 97:
 224  1867
          return jjMoveStringLiteralDfa1_0(0x2000L, 0x1L);
 225   
       case 98:
 226  1628
          return jjMoveStringLiteralDfa1_0(0x1c000L, 0x0L);
 227   
       case 99:
 228  2158
          return jjMoveStringLiteralDfa1_0(0x7e0000L, 0x0L);
 229   
       case 100:
 230  601
          return jjMoveStringLiteralDfa1_0(0x3800000L, 0x0L);
 231   
       case 101:
 232  1702
          return jjMoveStringLiteralDfa1_0(0xc000000L, 0x0L);
 233   
       case 102:
 234  3143
          return jjMoveStringLiteralDfa1_0(0x1f0000000L, 0x0L);
 235   
       case 103:
 236  4387
          return jjMoveStringLiteralDfa1_0(0x200000000L, 0x0L);
 237   
       case 105:
 238  7840
          return jjMoveStringLiteralDfa1_0(0xfc00000000L, 0x0L);
 239   
       case 108:
 240  502
          return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L);
 241   
       case 110:
 242  4154
          return jjMoveStringLiteralDfa1_0(0xe0000000000L, 0x0L);
 243   
       case 112:
 244  5525
          return jjMoveStringLiteralDfa1_0(0xf00000000000L, 0x0L);
 245   
       case 114:
 246  2976
          return jjMoveStringLiteralDfa1_0(0x1000000000000L, 0x0L);
 247   
       case 115:
 248  2957
          return jjMoveStringLiteralDfa1_0(0x803e000000000000L, 0x0L);
 249   
       case 116:
 250  3346
          return jjMoveStringLiteralDfa1_0(0xfc0000000000000L, 0x0L);
 251   
       case 118:
 252  1315
          return jjMoveStringLiteralDfa1_0(0x3000000000000000L, 0x0L);
 253   
       case 119:
 254  273
          return jjMoveStringLiteralDfa1_0(0x4000000000000000L, 0x0L);
 255   
       case 123:
 256  6262
          return jjStopAtPos(0, 78);
 257   
       case 124:
 258  100
          jjmatchedKind = 105;
 259  100
          return jjMoveStringLiteralDfa1_0(0x0L, 0x10000100000000L);
 260   
       case 125:
 261  6262
          return jjStopAtPos(0, 79);
 262   
       case 126:
 263  0
          return jjStopAtPos(0, 89);
 264   
       default :
 265  25513
          return jjMoveNfa_0(3, 0);
 266   
    }
 267   
 }
 268  57882
 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
 269   
 {
 270  57882
    try { curChar = input_stream.readChar(); }
 271   
    catch(java.io.IOException e) {
 272  0
       jjStopStringLiteralDfa_0(0, active0, active1);
 273  0
       return 1;
 274   
    }
 275  57882
    switch(curChar)
 276   
    {
 277   
       case 38:
 278  191
          if ((active1 & 0x200000000L) != 0L)
 279  191
             return jjStopAtPos(1, 97);
 280  0
          break;
 281   
       case 42:
 282  3124
          if ((active0 & 0x100L) != 0L)
 283  3124
             return jjStartNfaWithStates_0(1, 8, 0);
 284  0
          break;
 285   
       case 43:
 286  224
          if ((active1 & 0x400000000L) != 0L)
 287  133
             return jjStopAtPos(1, 98);
 288  91
          break;
 289   
       case 45:
 290  0
          if ((active1 & 0x800000000L) != 0L)
 291  0
             return jjStopAtPos(1, 99);
 292  0
          break;
 293   
       case 47:
 294  1662
          if ((active0 & 0x40L) != 0L)
 295  1662
             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  1778
          if ((active1 & 0x10000000L) != 0L)
 306  837
             return jjStopAtPos(1, 92);
 307  941
          else if ((active1 & 0x20000000L) != 0L)
 308  7
             return jjStopAtPos(1, 93);
 309  934
          else if ((active1 & 0x40000000L) != 0L)
 310  20
             return jjStopAtPos(1, 94);
 311  914
          else if ((active1 & 0x80000000L) != 0L)
 312  875
             return jjStopAtPos(1, 95);
 313  39
          else if ((active1 & 0x800000000000L) != 0L)
 314  23
             return jjStopAtPos(1, 111);
 315  16
          else if ((active1 & 0x1000000000000L) != 0L)
 316  0
             return jjStopAtPos(1, 112);
 317  16
          else if ((active1 & 0x2000000000000L) != 0L)
 318  0
             return jjStopAtPos(1, 113);
 319  16
          else if ((active1 & 0x4000000000000L) != 0L)
 320  0
             return jjStopAtPos(1, 114);
 321  16
          else if ((active1 & 0x8000000000000L) != 0L)
 322  0
             return jjStopAtPos(1, 115);
 323  16
          else if ((active1 & 0x10000000000000L) != 0L)
 324  16
             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  3381
          return jjMoveStringLiteralDfa2_0(active0, 0x120010060000L, active1, 0L);
 339   
       case 98:
 340  283
          return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
 341   
       case 101:
 342  9961
          return jjMoveStringLiteralDfa2_0(active0, 0x1040000800000L, active1, 0L);
 343   
       case 102:
 344  1956
          if ((active0 & 0x400000000L) != 0L)
 345  1952
             return jjStartNfaWithStates_0(1, 34, 32);
 346  4
          break;
 347   
       case 104:
 348  1195
          return jjMoveStringLiteralDfa2_0(active0, 0x41c2000000080000L, active1, 0L);
 349   
       case 105:
 350  2234
          return jjMoveStringLiteralDfa2_0(active0, 0x60000000L, active1, 0L);
 351   
       case 108:
 352  1802
          return jjMoveStringLiteralDfa2_0(active0, 0x84100000L, active1, 0L);
 353   
       case 109:
 354  1251
          return jjMoveStringLiteralDfa2_0(active0, 0x1800000000L, active1, 0L);
 355   
       case 110:
 356  1908
          return jjMoveStringLiteralDfa2_0(active0, 0xe000000000L, active1, 0L);
 357   
       case 111:
 358  5245
          if ((active0 & 0x1000000L) != 0L)
 359   
          {
 360  441
             jjmatchedKind = 24;
 361  441
             jjmatchedPos = 1;
 362   
          }
 363  5245
          return jjMoveStringLiteralDfa2_0(active0, 0x3000010302604000L, active1, 0L);
 364   
       case 114:
 365  2751
          return jjMoveStringLiteralDfa2_0(active0, 0xe00600000008000L, active1, 0L);
 366   
       case 115:
 367  1123
          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1L);
 368   
       case 116:
 369  1595
          return jjMoveStringLiteralDfa2_0(active0, 0x8004000000000000L, active1, 0L);
 370   
       case 117:
 371  6317
          return jjMoveStringLiteralDfa2_0(active0, 0x8880000000000L, active1, 0L);
 372   
       case 119:
 373  62
          return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000L, active1, 0L);
 374   
       case 120:
 375  295
          return jjMoveStringLiteralDfa2_0(active0, 0x8000000L, active1, 0L);
 376   
       case 121:
 377  28
          return jjMoveStringLiteralDfa2_0(active0, 0x20000000010000L, active1, 0L);
 378   
       case 124:
 379  84
          if ((active1 & 0x100000000L) != 0L)
 380  84
             return jjStopAtPos(1, 96);
 381  0
          break;
 382   
       default :
 383  9432
          break;
 384   
    }
 385  9527
    return jjStartNfa_0(0, active0, active1);
 386   
 }
 387  39431
 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
 388   
 {
 389  39431
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 390  12685
       return jjStartNfa_0(0, old0, old1); 
 391  26746
    try { curChar = input_stream.readChar(); }
 392   
    catch(java.io.IOException e) {
 393  0
       jjStopStringLiteralDfa_0(1, active0, active1);
 394  0
       return 2;
 395   
    }
 396  26746
    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  1531
          return jjMoveStringLiteralDfa3_0(active0, 0x204000000180000L, active1, 0L);
 413   
       case 98:
 414  2638
          return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L, active1, 0L);
 415   
       case 99:
 416  691
          return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L, active1, 0L);
 417   
       case 101:
 418  426
          return jjMoveStringLiteralDfa3_0(active0, 0x8000L, active1, 0L);
 419   
       case 102:
 420  94
          return jjMoveStringLiteralDfa3_0(active0, 0x800000L, active1, 0L);
 421   
       case 105:
 422  3144
          return jjMoveStringLiteralDfa3_0(active0, 0x5050200000000000L, active1, 0L);
 423   
       case 108:
 424  2656
          return jjMoveStringLiteralDfa3_0(active0, 0x2000080010000000L, active1, 0L);
 425   
       case 110:
 426  2065
          return jjMoveStringLiteralDfa3_0(active0, 0x20010060600000L, active1, 0L);
 427   
       case 111:
 428  1687
          return jjMoveStringLiteralDfa3_0(active0, 0x2400080004000L, active1, 0L);
 429   
       case 112:
 430  2234
          return jjMoveStringLiteralDfa3_0(active0, 0x8001800000000L, active1, 0L);
 431   
       case 114:
 432  1465
          if ((active0 & 0x100000000L) != 0L)
 433  521
             return jjStartNfaWithStates_0(2, 32, 32);
 434  944
          return jjMoveStringLiteralDfa3_0(active0, 0x8180000000000000L, active1, 0L);
 435   
       case 115:
 436  1310
          return jjMoveStringLiteralDfa3_0(active0, 0x2004022000L, active1, 0x1L);
 437   
       case 116:
 438  3717
          if ((active0 & 0x4000000000L) != 0L)
 439   
          {
 440  1126
             jjmatchedKind = 38;
 441  1126
             jjmatchedPos = 2;
 442   
          }
 443  3717
          return jjMoveStringLiteralDfa3_0(active0, 0x1028208050000L, active1, 0L);
 444   
       case 117:
 445  304
          return jjMoveStringLiteralDfa3_0(active0, 0x400000002000000L, active1, 0L);
 446   
       case 119:
 447  1376
          if ((active0 & 0x40000000000L) != 0L)
 448  1376
             return jjStartNfaWithStates_0(2, 42, 32);
 449  0
          break;
 450   
       case 121:
 451  67
          if ((active0 & 0x800000000000000L) != 0L)
 452  67
             return jjStartNfaWithStates_0(2, 59, 32);
 453  0
          break;
 454   
       default :
 455  1341
          break;
 456   
    }
 457  1341
    return jjStartNfa_0(1, active0, active1);
 458   
 }
 459  23441
 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
 460   
 {
 461  23441
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 462  2933
       return jjStartNfa_0(1, old0, old1); 
 463  20508
    try { curChar = input_stream.readChar(); }
 464   
    catch(java.io.IOException e) {
 465  0
       jjStopStringLiteralDfa_0(2, active0, active1);
 466  0
       return 3;
 467   
    }
 468  20508
    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  1367
          return jjMoveStringLiteralDfa4_0(active0, 0x20000000e0808000L, active1, 0L);
 476   
       case 98:
 477  0
          return jjMoveStringLiteralDfa4_0(active0, 0x2000000L, active1, 0L);
 478   
       case 99:
 479  87
          return jjMoveStringLiteralDfa4_0(active0, 0x20000000040000L, active1, 0L);
 480   
       case 100:
 481  947
          if ((active0 & 0x1000000000000000L) != 0L)
 482  935
             return jjStartNfaWithStates_0(3, 60, 32);
 483  12
          break;
 484   
       case 101:
 485  2635
          if ((active0 & 0x10000L) != 0L)
 486  0
             return jjStartNfaWithStates_0(3, 16, 32);
 487  2635
          else if ((active0 & 0x20000L) != 0L)
 488  0
             return jjStartNfaWithStates_0(3, 17, 32);
 489  2635
          else if ((active0 & 0x4000000L) != 0L)
 490  568
             return jjStartNfaWithStates_0(3, 26, 32);
 491  2067
          else if ((active0 & 0x400000000000000L) != 0L)
 492  274
             return jjStartNfaWithStates_0(3, 58, 32);
 493  1793
          return jjMoveStringLiteralDfa4_0(active0, 0x8008008000000L, active1, 0x1L);
 494   
       case 103:
 495  66
          if ((active0 & 0x10000000000L) != 0L)
 496  66
             return jjStartNfaWithStates_0(3, 40, 32);
 497  0
          break;
 498   
       case 105:
 499  73
          return jjMoveStringLiteralDfa4_0(active0, 0x8000020000000000L, active1, 0L);
 500   
       case 107:
 501  362
          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
 502   
       case 108:
 503  6282
          if ((active0 & 0x80000000000L) != 0L)
 504  2063
             return jjStartNfaWithStates_0(3, 43, 32);
 505  4219
          return jjMoveStringLiteralDfa4_0(active0, 0x4000800800004000L, active1, 0L);
 506   
       case 110:
 507  332
          return jjMoveStringLiteralDfa4_0(active0, 0x200000000000000L, active1, 0L);
 508   
       case 111:
 509  1552
          if ((active0 & 0x200000000L) != 0L)
 510  0
             return jjStartNfaWithStates_0(3, 33, 32);
 511  1552
          return jjMoveStringLiteralDfa4_0(active0, 0x180001000000000L, active1, 0L);
 512   
       case 114:
 513  102
          if ((active0 & 0x80000L) != 0L)
 514  73
             return jjStartNfaWithStates_0(3, 19, 32);
 515  29
          return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
 516   
       case 115:
 517  1277
          if ((active0 & 0x40000000000000L) != 0L)
 518  270
             return jjStartNfaWithStates_0(3, 54, 32);
 519  1007
          return jjMoveStringLiteralDfa4_0(active0, 0x10300000L, active1, 0L);
 520   
       case 116:
 521  925
          return jjMoveStringLiteralDfa4_0(active0, 0x14402000402000L, active1, 0L);
 522   
       case 117:
 523  2030
          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
 524   
       case 118:
 525  1251
          return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
 526   
       default :
 527  1220
          break;
 528   
    }
 529  1232
    return jjStartNfa_0(2, active0, active1);
 530   
 }
 531  15027
 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
 532   
 {
 533  15027
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 534  387
       return jjStartNfa_0(2, old0, old1); 
 535  14640
    try { curChar = input_stream.readChar(); }
 536   
    catch(java.io.IOException e) {
 537  0
       jjStopStringLiteralDfa_0(3, active0, active1);
 538  0
       return 4;
 539   
    }
 540  14640
    switch(curChar)
 541   
    {
 542   
       case 97:
 543  2057
          return jjMoveStringLiteralDfa5_0(active0, 0x302000000000L, active1, 0L);
 544   
       case 99:
 545  0
          return jjMoveStringLiteralDfa5_0(active0, 0x8010000000000000L, active1, 0L);
 546   
       case 101:
 547  2198
          if ((active0 & 0x10000000L) != 0L)
 548  314
             return jjStartNfaWithStates_0(4, 28, 32);
 549  1884
          else if ((active0 & 0x4000000000000000L) != 0L)
 550  185
             return jjStartNfaWithStates_0(4, 62, 32);
 551  1699
          return jjMoveStringLiteralDfa5_0(active0, 0x400800004000L, active1, 0L);
 552   
       case 104:
 553  87
          if ((active0 & 0x40000L) != 0L)
 554  87
             return jjStartNfaWithStates_0(4, 18, 32);
 555  0
          return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L, active1, 0L);
 556   
       case 105:
 557  2769
          return jjMoveStringLiteralDfa5_0(active0, 0x4800000400000L, active1, 0L);
 558   
       case 107:
 559  37
          if ((active0 & 0x8000L) != 0L)
 560  37
             return jjStartNfaWithStates_0(4, 15, 32);
 561  0
          break;
 562   
       case 108:
 563  1330
          if ((active0 & 0x20000000L) != 0L)
 564   
          {
 565  1330
             jjmatchedKind = 29;
 566  1330
             jjmatchedPos = 4;
 567   
          }
 568  1330
          return jjMoveStringLiteralDfa5_0(active0, 0x42000000L, active1, 0L);
 569   
       case 110:
 570  264
          return jjMoveStringLiteralDfa5_0(active0, 0x8000000L, active1, 0L);
 571   
       case 114:
 572  4606
          if ((active0 & 0x8000000000000L) != 0L)
 573  1088
             return jjStartNfaWithStates_0(4, 51, 32);
 574  3518
          return jjMoveStringLiteralDfa5_0(active0, 0x1009000002000L, active1, 0x1L);
 575   
       case 115:
 576  611
          if ((active0 & 0x100000L) != 0L)
 577  589
             return jjStartNfaWithStates_0(4, 20, 32);
 578  22
          return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L, active1, 0L);
 579   
       case 116:
 580  104
          if ((active0 & 0x200000L) != 0L)
 581  104
             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  577
          if ((active0 & 0x80000000000000L) != 0L)
 593   
          {
 594  577
             jjmatchedKind = 55;
 595  577
             jjmatchedPos = 4;
 596   
          }
 597  577
          return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L);
 598   
       default :
 599  0
          break;
 600   
    }
 601  0
    return jjStartNfa_0(3, active0, active1);
 602   
 }
 603  12236
 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
 604   
 {
 605  12236
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 606  286
       return jjStartNfa_0(3, old0, old1); 
 607  11950
    try { curChar = input_stream.readChar(); }
 608   
    catch(java.io.IOException e) {
 609  0
       jjStopStringLiteralDfa_0(4, active0, active1);
 610  0
       return 5;
 611   
    }
 612  11950
    switch(curChar)
 613   
    {
 614   
       case 97:
 615  1405
          return jjMoveStringLiteralDfa6_0(active0, 0x6000L, active1, 0L);
 616   
       case 99:
 617  2976
          if ((active0 & 0x800000000000L) != 0L)
 618  2548
             return jjStartNfaWithStates_0(5, 47, 32);
 619  428
          else if ((active0 & 0x4000000000000L) != 0L)
 620  215
             return jjStartNfaWithStates_0(5, 50, 32);
 621  213
          return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
 622   
       case 100:
 623  239
          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  456
          return jjMoveStringLiteralDfa6_0(active0, 0x8000000000L, active1, 0L);
 632   
       case 103:
 633  362
          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  128
          return jjMoveStringLiteralDfa6_0(active0, 0x800000000L, active1, 0L);
 644   
       case 110:
 645  2229
          if ((active0 & 0x1000000000000L) != 0L)
 646  2030
             return jjStartNfaWithStates_0(5, 48, 32);
 647  199
          return jjMoveStringLiteralDfa6_0(active0, 0x2000400000L, active1, 0L);
 648   
       case 114:
 649  0
          return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L);
 650   
       case 115:
 651  241
          if ((active0 & 0x100000000000000L) != 0L)
 652  241
             return jjStartNfaWithStates_0(5, 56, 32);
 653  0
          break;
 654   
       case 116:
 655  2258
          if ((active0 & 0x1000000000L) != 0L)
 656  975
             return jjStartNfaWithStates_0(5, 36, 32);
 657  1283
          else if ((active1 & 0x1L) != 0L)
 658  32
             return jjStartNfaWithStates_0(5, 64, 32);
 659  1251
          return jjMoveStringLiteralDfa6_0(active0, 0x8000200000000000L, active1, 0L);
 660   
       default :
 661  1656
          break;
 662   
    }
 663  1656
    return jjStartNfa_0(4, active0, active1);
 664   
 }
 665  4253
 private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
 666   
 {
 667  4253
    if (((active0 &= old0) | (active1 &= old1)) == 0L)
 668  32
       return jjStartNfa_0(4, old0, old1); 
 669  4221
    try { curChar = input_stream.readChar(); }
 670   
    catch(java.io.IOException e) {
 671  0
       jjStopStringLiteralDfa_0(5, active0, 0L);
 672  0
       return 6;
 673   
    }
 674  4221
    switch(curChar)
 675   
    {
 676   
       case 97:
 677  434
          return jjMoveStringLiteralDfa7_0(active0, 0x8000000000L);
 678   
       case 99:
 679  230
          return jjMoveStringLiteralDfa7_0(active0, 0x2000002000L);
 680   
       case 101:
 681  1741
          if ((active0 & 0x100000000000L) != 0L)
 682  362
             return jjStartNfaWithStates_0(6, 44, 32);
 683  1379
          else if ((active0 & 0x200000000000L) != 0L)
 684  1251
             return jjStartNfaWithStates_0(6, 45, 32);
 685  128
          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  1358
          if ((active0 & 0x4000L) != 0L)
 692  1358
             return jjStartNfaWithStates_0(6, 14, 32);
 693  0
          break;
 694   
       case 111:
 695  0
          return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L);
 696   
       case 115:
 697  239
          if ((active0 & 0x8000000L) != 0L)
 698  239
             return jjStartNfaWithStates_0(6, 27, 32);
 699  0
          break;
 700   
       case 116:
 701  213
          if ((active0 & 0x800000L) != 0L)
 702  0
             return jjStartNfaWithStates_0(6, 23, 32);
 703  213
          return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L);
 704   
       case 117:
 705  6
          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  1011
 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
 716   
 {
 717  1011
    if (((active0 &= old0)) == 0L)
 718  0
       return jjStartNfa_0(5, old0, 0L);
 719  1011
    try { curChar = input_stream.readChar(); }
 720   
    catch(java.io.IOException e) {
 721  0
       jjStopStringLiteralDfa_0(6, active0, 0L);
 722  0
       return 7;
 723   
    }
 724  1011
    switch(curChar)
 725   
    {
 726   
       case 99:
 727  412
          return jjMoveStringLiteralDfa8_0(active0, 0x8000000000L);
 728   
       case 101:
 729  402
          if ((active0 & 0x400000L) != 0L)
 730  6
             return jjStartNfaWithStates_0(7, 22, 32);
 731  396
          else if ((active0 & 0x2000000000000000L) != 0L)
 732  0
             return jjStartNfaWithStates_0(7, 61, 32);
 733  396
          return jjMoveStringLiteralDfa8_0(active0, 0x402000000000L);
 734   
       case 110:
 735  128
          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  47
          if ((active0 & 0x2000L) != 0L)
 742  47
             return jjStartNfaWithStates_0(7, 13, 32);
 743  0
          break;
 744   
       default :
 745  22
          break;
 746   
    }
 747  22
    return jjStartNfa_0(6, active0, 0L);
 748   
 }
 749  936
 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
 750   
 {
 751  936
    if (((active0 &= old0)) == 0L)
 752  0
       return jjStartNfa_0(6, old0, 0L);
 753  936
    try { curChar = input_stream.readChar(); }
 754   
    catch(java.io.IOException e) {
 755  0
       jjStopStringLiteralDfa_0(7, active0, 0L);
 756  0
       return 8;
 757   
    }
 758  936
    switch(curChar)
 759   
    {
 760   
       case 100:
 761  213
          if ((active0 & 0x400000000000L) != 0L)
 762  213
             return jjStartNfaWithStates_0(8, 46, 32);
 763  0
          break;
 764   
       case 101:
 765  412
          if ((active0 & 0x8000000000L) != 0L)
 766  412
             return jjStartNfaWithStates_0(8, 39, 32);
 767  0
          break;
 768   
       case 105:
 769  0
          return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L);
 770   
       case 111:
 771  43
          return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L);
 772   
       case 116:
 773  128
          if ((active0 & 0x200000000000000L) != 0L)
 774  0
             return jjStartNfaWithStates_0(8, 57, 32);
 775  128
          return jjMoveStringLiteralDfa9_0(active0, 0x800000000L);
 776   
       default :
 777  140
          break;
 778   
    }
 779  140
    return jjStartNfa_0(7, active0, 0L);
 780   
 }
 781  171
 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
 782   
 {
 783  171
    if (((active0 &= old0)) == 0L)
 784  0
       return jjStartNfa_0(7, old0, 0L);
 785  171
    try { curChar = input_stream.readChar(); }
 786   
    catch(java.io.IOException e) {
 787  0
       jjStopStringLiteralDfa_0(8, active0, 0L);
 788  0
       return 9;
 789   
    }
 790  171
    switch(curChar)
 791   
    {
 792   
       case 102:
 793  43
          if ((active0 & 0x2000000000L) != 0L)
 794  43
             return jjStartNfaWithStates_0(9, 37, 32);
 795  0
          break;
 796   
       case 115:
 797  106
          if ((active0 & 0x800000000L) != 0L)
 798  106
             return jjStartNfaWithStates_0(9, 35, 32);
 799  0
          break;
 800   
       case 122:
 801  22
          return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L);
 802   
       default :
 803  0
          break;
 804   
    }
 805  0
    return jjStartNfa_0(8, active0, 0L);
 806   
 }
 807  22
 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
 808   
 {
 809  22
    if (((active0 &= old0)) == 0L)
 810  22
       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  483379
 private final void jjCheckNAdd(int state)
 846   
 {
 847  483379
    if (jjrounds[state] != jjround)
 848   
    {
 849  483379
       jjstateSet[jjnewStateCnt++] = state;
 850  483379
       jjrounds[state] = jjround;
 851   
    }
 852   
 }
 853  397
 private final void jjAddStates(int start, int end)
 854   
 {
 855  397
    do {
 856  940
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 857  940
    } while (start++ != end);
 858   
 }
 859  606
 private final void jjCheckNAddTwoStates(int state1, int state2)
 860   
 {
 861  606
    jjCheckNAdd(state1);
 862  606
    jjCheckNAdd(state2);
 863   
 }
 864  29740
 private final void jjCheckNAddStates(int start, int end)
 865   
 {
 866  29740
    do {
 867  91856
       jjCheckNAdd(jjnextStates[start]);
 868  91856
    } 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  88464
 private final int jjMoveNfa_0(int startState, int curPos)
 900   
 {
 901  88464
    int[] nextStates;
 902  88464
    int startsAt = 0;
 903  88464
    jjnewStateCnt = 52;
 904  88464
    int i = 1;
 905  88464
    jjstateSet[0] = startState;
 906  88464
    int j, kind = 0x7fffffff;
 907  88464
    for (;;)
 908   
    {
 909  511343
       if (++jjround == 0x7fffffff)
 910  0
          ReInitRounds();
 911  511343
       if (curChar < 64)
 912   
       {
 913  90211
          long l = 1L << curChar;
 914  90211
          MatchLoop: do
 915   
          {
 916  110942
             switch(jjstateSet[--i])
 917   
             {
 918   
                case 3:
 919  2231
                   if ((0x3ff000000000000L & l) != 0L)
 920  659
                      jjCheckNAddStates(0, 6);
 921  1572
                   else if (curChar == 36)
 922   
                   {
 923  0
                      if (kind > 73)
 924  0
                         kind = 73;
 925  0
                      jjCheckNAdd(32);
 926   
                   }
 927  1572
                   else if (curChar == 34)
 928  1321
                      jjCheckNAddStates(7, 9);
 929  251
                   else if (curChar == 39)
 930  251
                      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  2231
                   if ((0x3fe000000000000L & l) != 0L)
 936   
                   {
 937  303
                      if (kind > 65)
 938  303
                         kind = 65;
 939  303
                      jjCheckNAddTwoStates(5, 6);
 940   
                   }
 941  1928
                   else if (curChar == 48)
 942   
                   {
 943  356
                      if (kind > 65)
 944  356
                         kind = 65;
 945  356
                      jjCheckNAddStates(12, 14);
 946   
                   }
 947  2231
                   break;
 948   
                case 0:
 949  3124
                   if (curChar == 42)
 950  2787
                      jjstateSet[jjnewStateCnt++] = 1;
 951  3124
                   break;
 952   
                case 1:
 953  2787
                   if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
 954  2787
                      kind = 7;
 955  2787
                   break;
 956   
                case 2:
 957  17
                   if (curChar == 42)
 958  0
                      jjstateSet[jjnewStateCnt++] = 0;
 959  17
                   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  400
                   if ((0x3ff000000000000L & l) == 0L)
 969  299
                      break;
 970  101
                   if (kind > 65)
 971  101
                      kind = 65;
 972  101
                   jjCheckNAddTwoStates(5, 6);
 973  101
                   break;
 974   
                case 7:
 975  0
                   if (curChar == 46)
 976  0
                      jjCheckNAdd(8);
 977  0
                   break;
 978   
                case 8:
 979  124
                   if ((0x3ff000000000000L & l) == 0L)
 980  124
                      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  227
                   if ((0xffffff7fffffdbffL & l) != 0L)
 1002  227
                      jjCheckNAdd(15);
 1003  227
                   break;
 1004   
                case 15:
 1005  251
                   if (curChar == 39 && kind > 71)
 1006  251
                      kind = 71;
 1007  251
                   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  7004
                   if ((0xfffffffbffffdbffL & l) != 0L)
 1034  5683
                      jjCheckNAddStates(7, 9);
 1035  7004
                   break;
 1036   
                case 25:
 1037  64
                   if ((0x8400000000L & l) != 0L)
 1038  64
                      jjCheckNAddStates(7, 9);
 1039  64
                   break;
 1040   
                case 26:
 1041  7004
                   if (curChar == 34 && kind > 72)
 1042  1321
                      kind = 72;
 1043  7004
                   break;
 1044   
                case 27:
 1045  64
                   if ((0xff000000000000L & l) != 0L)
 1046  0
                      jjCheckNAddStates(18, 21);
 1047  64
                   break;
 1048   
                case 28:
 1049  0
                   if ((0xff000000000000L & l) != 0L)
 1050  0
                      jjCheckNAddStates(7, 9);
 1051  0
                   break;
 1052   
                case 29:
 1053  64
                   if ((0xf000000000000L & l) != 0L)
 1054  0
                      jjstateSet[jjnewStateCnt++] = 30;
 1055  64
                   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  67406
                   if ((0x3ff001000000000L & l) == 0L)
 1069  67406
                      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  752
                   if ((0x3ff000000000000L & l) != 0L)
 1080  101
                      jjCheckNAddTwoStates(34, 35);
 1081  752
                   break;
 1082   
                case 35:
 1083  752
                   if (curChar != 46)
 1084  752
                      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  752
                   if ((0x3ff000000000000L & l) != 0L)
 1109  101
                      jjCheckNAddTwoStates(40, 41);
 1110  752
                   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  752
                   if ((0x3ff000000000000L & l) != 0L)
 1124  101
                      jjCheckNAddStates(25, 27);
 1125  752
                   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  352
                   if ((0xff000000000000L & l) == 0L)
 1150  352
                      break;
 1151  0
                   if (kind > 65)
 1152  0
                      kind = 65;
 1153  0
                   jjCheckNAddTwoStates(51, 6);
 1154  0
                   break;
 1155  16815
                default : break;
 1156   
             }
 1157  110942
          } while(i != startsAt);
 1158   
       }
 1159  421132
       else if (curChar < 128)
 1160   
       {
 1161  421132
          long l = 1L << (curChar & 077);
 1162  421132
          MatchLoop: do
 1163   
          {
 1164  464628
             switch(jjstateSet[--i])
 1165   
             {
 1166   
                case 3:
 1167   
                case 32:
 1168  390310
                   if ((0x7fffffe87fffffeL & l) == 0L)
 1169  250
                      break;
 1170  390060
                   if (kind > 73)
 1171  390060
                      kind = 73;
 1172  390060
                   jjCheckNAdd(32);
 1173  390060
                   break;
 1174   
                case 1:
 1175  0
                   if (kind > 7)
 1176  0
                      kind = 7;
 1177  0
                   break;
 1178   
                case 6:
 1179  8
                   if ((0x100000001000L & l) != 0L && kind > 65)
 1180  0
                      kind = 65;
 1181  8
                   break;
 1182   
                case 9:
 1183  0
                   if ((0x2000000020L & l) != 0L)
 1184  0
                      jjAddStates(28, 29);
 1185  0
                   break;
 1186   
                case 12:
 1187  8
                   if ((0x5000000050L & l) != 0L && kind > 69)
 1188  0
                      kind = 69;
 1189  8
                   break;
 1190   
                case 14:
 1191  24
                   if ((0xffffffffefffffffL & l) != 0L)
 1192  18
                      jjCheckNAdd(15);
 1193  24
                   break;
 1194   
                case 16:
 1195  24
                   if (curChar == 92)
 1196  6
                      jjAddStates(30, 32);
 1197  24
                   break;
 1198   
                case 17:
 1199  6
                   if ((0x14404410000000L & l) != 0L)
 1200  6
                      jjCheckNAdd(15);
 1201  6
                   break;
 1202   
                case 23:
 1203  21620
                   if ((0xffffffffefffffffL & l) != 0L)
 1204  21480
                      jjCheckNAddStates(7, 9);
 1205  21620
                   break;
 1206   
                case 24:
 1207  21620
                   if (curChar == 92)
 1208  140
                      jjAddStates(33, 35);
 1209  21620
                   break;
 1210   
                case 25:
 1211  76
                   if ((0x14404410000000L & l) != 0L)
 1212  76
                      jjCheckNAddStates(7, 9);
 1213  76
                   break;
 1214   
                case 37:
 1215  0
                   if ((0x2000000020L & l) != 0L)
 1216  0
                      jjAddStates(36, 37);
 1217  0
                   break;
 1218   
                case 41:
 1219  8
                   if ((0x2000000020L & l) != 0L)
 1220  0
                      jjAddStates(38, 39);
 1221  8
                   break;
 1222   
                case 45:
 1223  8
                   if ((0x2000000020L & l) != 0L)
 1224  0
                      jjAddStates(40, 41);
 1225  8
                   break;
 1226   
                case 49:
 1227  4
                   if ((0x100000001000000L & l) != 0L)
 1228  0
                      jjCheckNAdd(50);
 1229  4
                   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  30912
                default : break;
 1238   
             }
 1239  464628
          } 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  511343
       if (kind != 0x7fffffff)
 1277   
       {
 1278  395179
          jjmatchedKind = kind;
 1279  395179
          jjmatchedPos = curPos;
 1280  395179
          kind = 0x7fffffff;
 1281   
       }
 1282  511343
       ++curPos;
 1283  ?
       if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt)))
 1284  88464
          return curPos;
 1285  422879
       try { curChar = input_stream.readChar(); }
 1286  0
       catch(java.io.IOException e) { return curPos; }
 1287   
    }
 1288   
 }
 1289  35821
 private final int jjMoveStringLiteralDfa0_3()
 1290   
 {
 1291  35821
    switch(curChar)
 1292   
    {
 1293   
       case 42:
 1294  1208
          return jjMoveStringLiteralDfa1_3(0x800L);
 1295   
       default :
 1296  34613
          return 1;
 1297   
    }
 1298   
 }
 1299  1208
 private final int jjMoveStringLiteralDfa1_3(long active0)
 1300   
 {
 1301  1208
    try { curChar = input_stream.readChar(); }
 1302   
    catch(java.io.IOException e) {
 1303  0
       return 1;
 1304   
    }
 1305  1208
    switch(curChar)
 1306   
    {
 1307   
       case 47:
 1308  337
          if ((active0 & 0x800L) != 0L)
 1309  337
             return jjStopAtPos(1, 11);
 1310  0
          break;
 1311   
       default :
 1312  871
          return 2;
 1313   
    }
 1314  0
    return 2;
 1315   
 }
 1316  82431
 private final int jjMoveStringLiteralDfa0_1()
 1317   
 {
 1318  82431
    return jjMoveNfa_1(0, 0);
 1319   
 }
 1320  82431
 private final int jjMoveNfa_1(int startState, int curPos)
 1321   
 {
 1322  82431
    int[] nextStates;
 1323  82431
    int startsAt = 0;
 1324  82431
    jjnewStateCnt = 3;
 1325  82431
    int i = 1;
 1326  82431
    jjstateSet[0] = startState;
 1327  82431
    int j, kind = 0x7fffffff;
 1328  82431
    for (;;)
 1329   
    {
 1330  82431
       if (++jjround == 0x7fffffff)
 1331  0
          ReInitRounds();
 1332  82431
       if (curChar < 64)
 1333   
       {
 1334  19352
          long l = 1L << curChar;
 1335  19352
          MatchLoop: do
 1336   
          {
 1337  19352
             switch(jjstateSet[--i])
 1338   
             {
 1339   
                case 0:
 1340  19352
                   if ((0x2400L & l) != 0L)
 1341   
                   {
 1342  1662
                      if (kind > 9)
 1343  1662
                         kind = 9;
 1344   
                   }
 1345  19352
                   if (curChar == 13)
 1346  0
                      jjstateSet[jjnewStateCnt++] = 1;
 1347  19352
                   break;
 1348   
                case 1:
 1349  0
                   if (curChar == 10 && kind > 9)
 1350  0
                      kind = 9;
 1351  0
                   break;
 1352   
                case 2:
 1353  0
                   if (curChar == 13)
 1354  0
                      jjstateSet[jjnewStateCnt++] = 1;
 1355  0
                   break;
 1356  0
                default : break;
 1357   
             }
 1358  19352
          } while(i != startsAt);
 1359   
       }
 1360  63079
       else if (curChar < 128)
 1361   
       {
 1362  63079
          long l = 1L << (curChar & 077);
 1363  63079
          MatchLoop: do
 1364   
          {
 1365  63079
             switch(jjstateSet[--i])
 1366   
             {
 1367  63079
                default : break;
 1368   
             }
 1369  63079
          } 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  82431
       if (kind != 0x7fffffff)
 1387   
       {
 1388  1662
          jjmatchedKind = kind;
 1389  1662
          jjmatchedPos = curPos;
 1390  1662
          kind = 0x7fffffff;
 1391   
       }
 1392  82431
       ++curPos;
 1393  ?
       if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
 1394  82431
          return curPos;
 1395  0
       try { curChar = input_stream.readChar(); }
 1396  0
       catch(java.io.IOException e) { return curPos; }
 1397   
    }
 1398   
 }
 1399  417955
 private final int jjMoveStringLiteralDfa0_2()
 1400   
 {
 1401  417955
    switch(curChar)
 1402   
    {
 1403   
       case 42:
 1404  13666
          return jjMoveStringLiteralDfa1_2(0x400L);
 1405   
       default :
 1406  404289
          return 1;
 1407   
    }
 1408   
 }
 1409  13666
 private final int jjMoveStringLiteralDfa1_2(long active0)
 1410   
 {
 1411  13666
    try { curChar = input_stream.readChar(); }
 1412   
    catch(java.io.IOException e) {
 1413  0
       return 1;
 1414   
    }
 1415  13666
    switch(curChar)
 1416   
    {
 1417   
       case 47:
 1418  2787
          if ((active0 & 0x400L) != 0L)
 1419  2787
             return jjStopAtPos(1, 10);
 1420  0
          break;
 1421   
       default :
 1422  10879
          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  336
 public SimpleParserTokenManager(JavaCharStream stream)
 1519   
 {
 1520  336
    if (JavaCharStream.staticFlag)
 1521  0
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 1522  336
    input_stream = stream;
 1523   
 }
 1524  0
 public SimpleParserTokenManager(JavaCharStream stream, int lexState)
 1525   
 {
 1526  0
    this(stream);
 1527  0
    SwitchTo(lexState);
 1528   
 }
 1529  336
 public void ReInit(JavaCharStream stream)
 1530   
 {
 1531  336
    jjmatchedPos = jjnewStateCnt = 0;
 1532  336
    curLexState = defaultLexState;
 1533  336
    input_stream = stream;
 1534  336
    ReInitRounds();
 1535   
 }
 1536  336
 private final void ReInitRounds()
 1537   
 {
 1538  336
    int i;
 1539  336
    jjround = 0x80000001;
 1540  336
    for (i = 52; i-- > 0;)
 1541  17472
       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  348518
 private final Token jjFillToken()
 1557   
 {
 1558  348518
    Token t = Token.newToken(jjmatchedKind);
 1559  348518
    t.kind = jjmatchedKind;
 1560  348518
    String im = jjstrLiteralImages[jjmatchedKind];
 1561  348518
    t.image = (im == null) ? input_stream.GetImage() : im;
 1562  348518
    t.beginLine = input_stream.getBeginLine();
 1563  348518
    t.beginColumn = input_stream.getBeginColumn();
 1564  348518
    t.endLine = input_stream.getEndLine();
 1565  348518
    t.endColumn = input_stream.getEndColumn();
 1566  348518
    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  151692
 public final Token getNextToken() 
 1577   
 {
 1578  151692
   int kind;
 1579  151692
   Token specialToken = null;
 1580  151692
   Token matchedToken;
 1581  151692
   int curPos = 0;
 1582   
 
 1583  151692
   EOFLoop :
 1584   
   for (;;)
 1585   
   {   
 1586  348518
    try   
 1587   
    {     
 1588  348518
       curChar = input_stream.BeginToken();
 1589   
    }     
 1590   
    catch(java.io.IOException e)
 1591   
    {        
 1592  1008
       jjmatchedKind = 0;
 1593  1008
       matchedToken = jjFillToken();
 1594  1008
       matchedToken.specialToken = specialToken;
 1595  1008
       return matchedToken;
 1596   
    }
 1597  347510
    image = null;
 1598  347510
    jjimageLen = 0;
 1599   
 
 1600  347510
    for (;;)
 1601   
    {
 1602  883717
      switch(curLexState)
 1603   
      {
 1604   
        case 0:
 1605  347510
          jjmatchedKind = 0x7fffffff;
 1606  347510
          jjmatchedPos = 0;
 1607  347510
          curPos = jjMoveStringLiteralDfa0_0();
 1608  347510
          break;
 1609   
        case 1:
 1610  82431
          jjmatchedKind = 0x7fffffff;
 1611  82431
          jjmatchedPos = 0;
 1612  82431
          curPos = jjMoveStringLiteralDfa0_1();
 1613  82431
          if (jjmatchedPos == 0 && jjmatchedKind > 12)
 1614   
          {
 1615  80769
             jjmatchedKind = 12;
 1616   
          }
 1617  82431
          break;
 1618   
        case 2:
 1619  417955
          jjmatchedKind = 0x7fffffff;
 1620  417955
          jjmatchedPos = 0;
 1621  417955
          curPos = jjMoveStringLiteralDfa0_2();
 1622  417955
          if (jjmatchedPos == 0 && jjmatchedKind > 12)
 1623   
          {
 1624  415168
             jjmatchedKind = 12;
 1625   
          }
 1626  417955
          break;
 1627   
        case 3:
 1628  35821
          jjmatchedKind = 0x7fffffff;
 1629  35821
          jjmatchedPos = 0;
 1630  35821
          curPos = jjMoveStringLiteralDfa0_3();
 1631  35821
          if (jjmatchedPos == 0 && jjmatchedKind > 12)
 1632   
          {
 1633  35484
             jjmatchedKind = 12;
 1634   
          }
 1635  35821
          break;
 1636   
      }
 1637  883717
      if (jjmatchedKind != 0x7fffffff)
 1638   
      {
 1639  883717
         if (jjmatchedPos + 1 < curPos)
 1640  95855
            input_stream.backup(curPos - jjmatchedPos - 1);
 1641  883717
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1642   
         {
 1643  150684
            matchedToken = jjFillToken();
 1644  150684
            matchedToken.specialToken = specialToken;
 1645  150684
        if (jjnewLexState[jjmatchedKind] != -1)
 1646  0
          curLexState = jjnewLexState[jjmatchedKind];
 1647  150684
            return matchedToken;
 1648   
         }
 1649  733033
         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1650   
         {
 1651  196826
            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1652   
            {
 1653  196826
               matchedToken = jjFillToken();
 1654  196826
               if (specialToken == null)
 1655  91814
                  specialToken = matchedToken;
 1656   
               else
 1657   
               {
 1658  105012
                  matchedToken.specialToken = specialToken;
 1659  105012
                  specialToken = (specialToken.next = matchedToken);
 1660   
               }
 1661  196826
               SkipLexicalActions(matchedToken);
 1662   
            }
 1663   
            else 
 1664  0
               SkipLexicalActions(null);
 1665  196826
          if (jjnewLexState[jjmatchedKind] != -1)
 1666  4786
            curLexState = jjnewLexState[jjmatchedKind];
 1667  196826
            continue EOFLoop;
 1668   
         }
 1669  536207
         MoreLexicalActions();
 1670  536207
       if (jjnewLexState[jjmatchedKind] != -1)
 1671  4786
         curLexState = jjnewLexState[jjmatchedKind];
 1672  536207
         curPos = 0;
 1673  536207
         jjmatchedKind = 0x7fffffff;
 1674  536207
         try {
 1675  536207
            curChar = input_stream.readChar();
 1676  536207
            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  196826
 final void SkipLexicalActions(Token matchedToken)
 1705   
 {
 1706  196826
    switch(jjmatchedKind)
 1707   
    {
 1708   
       default :
 1709  196826
          break;
 1710   
    }
 1711   
 }
 1712  536207
 final void MoreLexicalActions()
 1713   
 {
 1714  536207
    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
 1715  536207
    switch(jjmatchedKind)
 1716   
    {
 1717   
       case 7 :
 1718  2787
          if (image == null)
 1719  2787
               image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
 1720   
          else
 1721  0
             image.append(input_stream.GetSuffix(jjimageLen));
 1722  2787
          jjimageLen = 0;
 1723  2787
                    input_stream.backup(1);
 1724  2787
          break;
 1725   
       default : 
 1726  533420
          break;
 1727   
    }
 1728   
 }
 1729   
 }
 1730