View Javadoc

1   /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */
2   package net.sourceforge.pmd.ast;
3   
4   public class JavaParserTokenManager implements JavaParserConstants
5   {
6     public  java.io.PrintStream debugStream = System.out;
7     public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
8   private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
9   {
10     switch (pos)
11     {
12        case 0:
13           if ((active1 & 0x40000000040000L) != 0L)
14              return 4;
15           if ((active0 & 0x7ffffffffffff000L) != 0L)
16           {
17              jjmatchedKind = 71;
18              return 28;
19           }
20           if ((active0 & 0x100L) != 0L || (active1 & 0x402000000000L) != 0L)
21              return 49;
22           return -1;
23        case 1:
24           if ((active0 & 0x201800000L) != 0L)
25              return 28;
26           if ((active0 & 0x7ffffffdfe7ff000L) != 0L)
27           {
28              if (jjmatchedPos != 1)
29              {
30                 jjmatchedKind = 71;
31                 jjmatchedPos = 1;
32              }
33              return 28;
34           }
35           if ((active0 & 0x100L) != 0L)
36              return 54;
37           return -1;
38        case 2:
39           if ((active0 & 0x400026080000000L) != 0L)
40              return 28;
41           if ((active0 & 0x7bfffd9d7f7ff000L) != 0L)
42           {
43              if (jjmatchedPos != 2)
44              {
45                 jjmatchedKind = 71;
46                 jjmatchedPos = 2;
47              }
48              return 28;
49           }
50           return -1;
51        case 3:
52           if ((active0 & 0xa20048102058000L) != 0L)
53              return 28;
54           if ((active0 & 0x71dff95c7d7a7000L) != 0L)
55           {
56              jjmatchedKind = 71;
57              jjmatchedPos = 3;
58              return 28;
59           }
60           return -1;
61        case 4:
62           if ((active0 & 0x20c50000781a4000L) != 0L)
63              return 28;
64           if ((active0 & 0x511af95c05603000L) != 0L)
65           {
66              if (jjmatchedPos != 4)
67              {
68                 jjmatchedKind = 71;
69                 jjmatchedPos = 4;
70              }
71              return 28;
72           }
73           return -1;
74        case 5:
75           if ((active0 & 0x8ac10801000000L) != 0L)
76              return 28;
77           if ((active0 & 0x5110385424603000L) != 0L)
78           {
79              jjmatchedKind = 71;
80              jjmatchedPos = 5;
81              return 28;
82           }
83           return -1;
84        case 6:
85           if ((active0 & 0x5110205400201000L) != 0L)
86           {
87              jjmatchedKind = 71;
88              jjmatchedPos = 6;
89              return 28;
90           }
91           if ((active0 & 0x180024402000L) != 0L)
92              return 28;
93           return -1;
94        case 7:
95           if ((active0 & 0x5000000000201000L) != 0L)
96              return 28;
97           if ((active0 & 0x110205400000000L) != 0L)
98           {
99              jjmatchedKind = 71;
100             jjmatchedPos = 7;
101             return 28;
102          }
103          return -1;
104       case 8:
105          if ((active0 & 0x100204000000000L) != 0L)
106             return 28;
107          if ((active0 & 0x10001400000000L) != 0L)
108          {
109             jjmatchedKind = 71;
110             jjmatchedPos = 8;
111             return 28;
112          }
113          return -1;
114       case 9:
115          if ((active0 & 0x10000000000000L) != 0L)
116          {
117             jjmatchedKind = 71;
118             jjmatchedPos = 9;
119             return 28;
120          }
121          if ((active0 & 0x1400000000L) != 0L)
122             return 28;
123          return -1;
124       case 10:
125          if ((active0 & 0x10000000000000L) != 0L)
126          {
127             jjmatchedKind = 71;
128             jjmatchedPos = 10;
129             return 28;
130          }
131          return -1;
132       default :
133          return -1;
134    }
135 }
136 private final int jjStartNfa_0(int pos, long active0, long active1)
137 {
138    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
139 }
140 private final int jjStopAtPos(int pos, int kind)
141 {
142    jjmatchedKind = kind;
143    jjmatchedPos = pos;
144    return pos + 1;
145 }
146 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
147 {
148    jjmatchedKind = kind;
149    jjmatchedPos = pos;
150    try { curChar = input_stream.readChar(); }
151    catch(java.io.IOException e) { return pos + 1; }
152    return jjMoveNfa_0(state, pos + 1);
153 }
154 private final int jjMoveStringLiteralDfa0_0()
155 {
156    switch(curChar)
157    {
158       case 9:
159          return jjStopAtPos(0, 2);
160       case 10:
161          return jjStopAtPos(0, 3);
162       case 12:
163          return jjStopAtPos(0, 5);
164       case 13:
165          return jjStopAtPos(0, 4);
166       case 26:
167          return jjStopAtPos(0, 122);
168       case 32:
169          return jjStopAtPos(0, 1);
170       case 33:
171          jjmatchedKind = 86;
172          return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000L);
173       case 37:
174          jjmatchedKind = 105;
175          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000000L);
176       case 38:
177          jjmatchedKind = 102;
178          return jjMoveStringLiteralDfa1_0(0x0L, 0x800080000000L);
179       case 40:
180          return jjStopAtPos(0, 74);
181       case 41:
182          return jjStopAtPos(0, 75);
183       case 42:
184          jjmatchedKind = 100;
185          return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000L);
186       case 43:
187          jjmatchedKind = 98;
188          return jjMoveStringLiteralDfa1_0(0x0L, 0x80100000000L);
189       case 44:
190          return jjStopAtPos(0, 81);
191       case 45:
192          jjmatchedKind = 99;
193          return jjMoveStringLiteralDfa1_0(0x0L, 0x100200000000L);
194       case 46:
195          jjmatchedKind = 82;
196          return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
197       case 47:
198          jjmatchedKind = 101;
199          return jjMoveStringLiteralDfa1_0(0x100L, 0x400000000000L);
200       case 58:
201          return jjStopAtPos(0, 89);
202       case 59:
203          return jjStopAtPos(0, 80);
204       case 60:
205          jjmatchedKind = 85;
206          return jjMoveStringLiteralDfa1_0(0x0L, 0x8040008000000L);
207       case 61:
208          jjmatchedKind = 84;
209          return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000L);
210       case 62:
211          jjmatchedKind = 121;
212          return jjMoveStringLiteralDfa1_0(0x0L, 0x1b0000010000000L);
213       case 63:
214          return jjStopAtPos(0, 88);
215       case 64:
216          return jjStopAtPos(0, 83);
217       case 91:
218          return jjStopAtPos(0, 78);
219       case 93:
220          return jjStopAtPos(0, 79);
221       case 94:
222          jjmatchedKind = 104;
223          return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
224       case 97:
225          return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);
226       case 98:
227          return jjMoveStringLiteralDfa1_0(0xe000L, 0x0L);
228       case 99:
229          return jjMoveStringLiteralDfa1_0(0x3f0000L, 0x0L);
230       case 100:
231          return jjMoveStringLiteralDfa1_0(0x1c00000L, 0x0L);
232       case 101:
233          return jjMoveStringLiteralDfa1_0(0x6000000L, 0x0L);
234       case 102:
235          return jjMoveStringLiteralDfa1_0(0xf8000000L, 0x0L);
236       case 103:
237          return jjMoveStringLiteralDfa1_0(0x100000000L, 0x0L);
238       case 105:
239          return jjMoveStringLiteralDfa1_0(0x7e00000000L, 0x0L);
240       case 108:
241          return jjMoveStringLiteralDfa1_0(0x8000000000L, 0x0L);
242       case 110:
243          return jjMoveStringLiteralDfa1_0(0x70000000000L, 0x0L);
244       case 112:
245          return jjMoveStringLiteralDfa1_0(0x780000000000L, 0x0L);
246       case 114:
247          return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L);
248       case 115:
249          return jjMoveStringLiteralDfa1_0(0x401f000000000000L, 0x0L);
250       case 116:
251          return jjMoveStringLiteralDfa1_0(0x7e0000000000000L, 0x0L);
252       case 118:
253          return jjMoveStringLiteralDfa1_0(0x1800000000000000L, 0x0L);
254       case 119:
255          return jjMoveStringLiteralDfa1_0(0x2000000000000000L, 0x0L);
256       case 123:
257          return jjStopAtPos(0, 76);
258       case 124:
259          jjmatchedKind = 103;
260          return jjMoveStringLiteralDfa1_0(0x0L, 0x1000040000000L);
261       case 125:
262          return jjStopAtPos(0, 77);
263       case 126:
264          jjmatchedKind = 87;
265          return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000000L);
266       default :
267          return jjMoveNfa_0(0, 0);
268    }
269 }
270 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
271 {
272    try { curChar = input_stream.readChar(); }
273    catch(java.io.IOException e) {
274       jjStopStringLiteralDfa_0(0, active0, active1);
275       return 1;
276    }
277    switch(curChar)
278    {
279       case 38:
280          if ((active1 & 0x80000000L) != 0L)
281             return jjStopAtPos(1, 95);
282          break;
283       case 42:
284          if ((active0 & 0x100L) != 0L)
285             return jjStartNfaWithStates_0(1, 8, 54);
286          break;
287       case 43:
288          if ((active1 & 0x100000000L) != 0L)
289             return jjStopAtPos(1, 96);
290          break;
291       case 45:
292          if ((active1 & 0x200000000L) != 0L)
293             return jjStopAtPos(1, 97);
294          break;
295       case 46:
296          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000000000000L);
297       case 60:
298          if ((active1 & 0x40000000000L) != 0L)
299          {
300             jjmatchedKind = 106;
301             jjmatchedPos = 1;
302          }
303          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000000000000L);
304       case 61:
305          if ((active1 & 0x4000000L) != 0L)
306             return jjStopAtPos(1, 90);
307          else if ((active1 & 0x8000000L) != 0L)
308             return jjStopAtPos(1, 91);
309          else if ((active1 & 0x10000000L) != 0L)
310             return jjStopAtPos(1, 92);
311          else if ((active1 & 0x20000000L) != 0L)
312             return jjStopAtPos(1, 93);
313          else if ((active1 & 0x80000000000L) != 0L)
314             return jjStopAtPos(1, 107);
315          else if ((active1 & 0x100000000000L) != 0L)
316             return jjStopAtPos(1, 108);
317          else if ((active1 & 0x200000000000L) != 0L)
318             return jjStopAtPos(1, 109);
319          else if ((active1 & 0x400000000000L) != 0L)
320             return jjStopAtPos(1, 110);
321          else if ((active1 & 0x800000000000L) != 0L)
322             return jjStopAtPos(1, 111);
323          else if ((active1 & 0x1000000000000L) != 0L)
324             return jjStopAtPos(1, 112);
325          else if ((active1 & 0x2000000000000L) != 0L)
326             return jjStopAtPos(1, 113);
327          else if ((active1 & 0x4000000000000L) != 0L)
328             return jjStopAtPos(1, 114);
329          break;
330       case 62:
331          if ((active1 & 0x100000000000000L) != 0L)
332          {
333             jjmatchedKind = 120;
334             jjmatchedPos = 1;
335          }
336          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0xb0000000000000L);
337       case 91:
338          return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800000000000000L);
339       case 97:
340          return jjMoveStringLiteralDfa2_0(active0, 0x90008030000L, active1, 0L);
341       case 98:
342          return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L);
343       case 101:
344          return jjMoveStringLiteralDfa2_0(active0, 0x820000400000L, active1, 0L);
345       case 102:
346          if ((active0 & 0x200000000L) != 0L)
347             return jjStartNfaWithStates_0(1, 33, 28);
348          break;
349       case 104:
350          return jjMoveStringLiteralDfa2_0(active0, 0x20e1000000040000L, active1, 0L);
351       case 105:
352          return jjMoveStringLiteralDfa2_0(active0, 0x30000000L, active1, 0L);
353       case 108:
354          return jjMoveStringLiteralDfa2_0(active0, 0x42080000L, active1, 0L);
355       case 109:
356          return jjMoveStringLiteralDfa2_0(active0, 0xc00000000L, active1, 0L);
357       case 110:
358          return jjMoveStringLiteralDfa2_0(active0, 0x7000000000L, active1, 0L);
359       case 111:
360          if ((active0 & 0x800000L) != 0L)
361          {
362             jjmatchedKind = 23;
363             jjmatchedPos = 1;
364          }
365          return jjMoveStringLiteralDfa2_0(active0, 0x1800008181302000L, active1, 0L);
366       case 114:
367          return jjMoveStringLiteralDfa2_0(active0, 0x700300000004000L, active1, 0L);
368       case 116:
369          return jjMoveStringLiteralDfa2_0(active0, 0x4002000000000000L, active1, 0L);
370       case 117:
371          return jjMoveStringLiteralDfa2_0(active0, 0x4440000000000L, active1, 0L);
372       case 119:
373          return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L, active1, 0L);
374       case 120:
375          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L, active1, 0L);
376       case 121:
377          return jjMoveStringLiteralDfa2_0(active0, 0x10000000008000L, active1, 0L);
378       case 124:
379          if ((active1 & 0x40000000L) != 0L)
380             return jjStopAtPos(1, 94);
381          break;
382       default :
383          break;
384    }
385    return jjStartNfa_0(0, active0, active1);
386 }
387 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
388 {
389    if (((active0 &= old0) | (active1 &= old1)) == 0L)
390       return jjStartNfa_0(0, old0, old1); 
391    try { curChar = input_stream.readChar(); }
392    catch(java.io.IOException e) {
393       jjStopStringLiteralDfa_0(1, active0, active1);
394       return 2;
395    }
396    switch(curChar)
397    {
398       case 46:
399          if ((active1 & 0x40000000000000L) != 0L)
400             return jjStopAtPos(2, 118);
401          break;
402       case 61:
403          if ((active1 & 0x8000000000000L) != 0L)
404             return jjStopAtPos(2, 115);
405          else if ((active1 & 0x10000000000000L) != 0L)
406             return jjStopAtPos(2, 116);
407          break;
408       case 62:
409          if ((active1 & 0x80000000000000L) != 0L)
410          {
411             jjmatchedKind = 119;
412             jjmatchedPos = 2;
413          }
414          return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x20000000000000L);
415       case 93:
416          if ((active1 & 0x800000000000000L) != 0L)
417             return jjStopAtPos(2, 123);
418          break;
419       case 97:
420          return jjMoveStringLiteralDfa3_0(active0, 0x1020000000c0000L, active1, 0L);
421       case 98:
422          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L);
423       case 99:
424          return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0L);
425       case 101:
426          return jjMoveStringLiteralDfa3_0(active0, 0x4000L, active1, 0L);
427       case 102:
428          return jjMoveStringLiteralDfa3_0(active0, 0x400000L, active1, 0L);
429       case 105:
430          return jjMoveStringLiteralDfa3_0(active0, 0x2828100000000000L, active1, 0L);
431       case 108:
432          return jjMoveStringLiteralDfa3_0(active0, 0x1000040008000000L, active1, 0L);
433       case 110:
434          return jjMoveStringLiteralDfa3_0(active0, 0x10008030300000L, active1, 0L);
435       case 111:
436          return jjMoveStringLiteralDfa3_0(active0, 0x1200040002000L, active1, 0L);
437       case 112:
438          return jjMoveStringLiteralDfa3_0(active0, 0x4000c00000000L, active1, 0L);
439       case 114:
440          if ((active0 & 0x80000000L) != 0L)
441             return jjStartNfaWithStates_0(2, 31, 28);
442          return jjMoveStringLiteralDfa3_0(active0, 0x40c0000000000000L, active1, 0L);
443       case 115:
444          return jjMoveStringLiteralDfa3_0(active0, 0x1002011000L, active1, 0L);
445       case 116:
446          if ((active0 & 0x2000000000L) != 0L)
447          {
448             jjmatchedKind = 37;
449             jjmatchedPos = 2;
450          }
451          return jjMoveStringLiteralDfa3_0(active0, 0x814104028000L, active1, 0L);
452       case 117:
453          return jjMoveStringLiteralDfa3_0(active0, 0x200000001000000L, active1, 0L);
454       case 119:
455          if ((active0 & 0x20000000000L) != 0L)
456             return jjStartNfaWithStates_0(2, 41, 28);
457          break;
458       case 121:
459          if ((active0 & 0x400000000000000L) != 0L)
460             return jjStartNfaWithStates_0(2, 58, 28);
461          break;
462       default :
463          break;
464    }
465    return jjStartNfa_0(1, active0, active1);
466 }
467 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
468 {
469    if (((active0 &= old0) | (active1 &= old1)) == 0L)
470       return jjStartNfa_0(1, old0, old1); 
471    try { curChar = input_stream.readChar(); }
472    catch(java.io.IOException e) {
473       jjStopStringLiteralDfa_0(2, active0, active1);
474       return 3;
475    }
476    switch(curChar)
477    {
478       case 61:
479          if ((active1 & 0x20000000000000L) != 0L)
480             return jjStopAtPos(3, 117);
481          break;
482       case 97:
483          return jjMoveStringLiteralDfa4_0(active0, 0x1000000070404000L, active1, 0L);
484       case 98:
485          return jjMoveStringLiteralDfa4_0(active0, 0x1000000L, active1, 0L);
486       case 99:
487          return jjMoveStringLiteralDfa4_0(active0, 0x10000000020000L, active1, 0L);
488       case 100:
489          if ((active0 & 0x800000000000000L) != 0L)
490             return jjStartNfaWithStates_0(3, 59, 28);
491          break;
492       case 101:
493          if ((active0 & 0x8000L) != 0L)
494             return jjStartNfaWithStates_0(3, 15, 28);
495          else if ((active0 & 0x10000L) != 0L)
496             return jjStartNfaWithStates_0(3, 16, 28);
497          else if ((active0 & 0x2000000L) != 0L)
498             return jjStartNfaWithStates_0(3, 25, 28);
499          else if ((active0 & 0x200000000000000L) != 0L)
500             return jjStartNfaWithStates_0(3, 57, 28);
501          return jjMoveStringLiteralDfa4_0(active0, 0x4004004000000L, active1, 0L);
502       case 103:
503          if ((active0 & 0x8000000000L) != 0L)
504             return jjStartNfaWithStates_0(3, 39, 28);
505          break;
506       case 105:
507          return jjMoveStringLiteralDfa4_0(active0, 0x4000010000000000L, active1, 0L);
508       case 107:
509          return jjMoveStringLiteralDfa4_0(active0, 0x80000000000L, active1, 0L);
510       case 108:
511          if ((active0 & 0x40000000000L) != 0L)
512             return jjStartNfaWithStates_0(3, 42, 28);
513          return jjMoveStringLiteralDfa4_0(active0, 0x2000400400002000L, active1, 0L);
514       case 110:
515          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000000L, active1, 0L);
516       case 111:
517          if ((active0 & 0x100000000L) != 0L)
518             return jjStartNfaWithStates_0(3, 32, 28);
519          return jjMoveStringLiteralDfa4_0(active0, 0xc0000800000000L, active1, 0L);
520       case 114:
521          if ((active0 & 0x40000L) != 0L)
522             return jjStartNfaWithStates_0(3, 18, 28);
523          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L, active1, 0L);
524       case 115:
525          if ((active0 & 0x20000000000000L) != 0L)
526             return jjStartNfaWithStates_0(3, 53, 28);
527          return jjMoveStringLiteralDfa4_0(active0, 0x8180000L, active1, 0L);
528       case 116:
529          return jjMoveStringLiteralDfa4_0(active0, 0xa201000201000L, active1, 0L);
530       case 117:
531          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L);
532       case 118:
533          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
534       default :
535          break;
536    }
537    return jjStartNfa_0(2, active0, active1);
538 }
539 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
540 {
541    if (((active0 &= old0) | (active1 &= old1)) == 0L)
542       return jjStartNfa_0(2, old0, old1); 
543    try { curChar = input_stream.readChar(); }
544    catch(java.io.IOException e) {
545       jjStopStringLiteralDfa_0(3, active0, 0L);
546       return 4;
547    }
548    switch(curChar)
549    {
550       case 97:
551          return jjMoveStringLiteralDfa5_0(active0, 0x181000000000L);
552       case 99:
553          return jjMoveStringLiteralDfa5_0(active0, 0x4008000000000000L);
554       case 101:
555          if ((active0 & 0x8000000L) != 0L)
556             return jjStartNfaWithStates_0(4, 27, 28);
557          else if ((active0 & 0x2000000000000000L) != 0L)
558             return jjStartNfaWithStates_0(4, 61, 28);
559          return jjMoveStringLiteralDfa5_0(active0, 0x200400002000L);
560       case 104:
561          if ((active0 & 0x20000L) != 0L)
562             return jjStartNfaWithStates_0(4, 17, 28);
563          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
564       case 105:
565          return jjMoveStringLiteralDfa5_0(active0, 0x2400000200000L);
566       case 107:
567          if ((active0 & 0x4000L) != 0L)
568             return jjStartNfaWithStates_0(4, 14, 28);
569          break;
570       case 108:
571          if ((active0 & 0x10000000L) != 0L)
572          {
573             jjmatchedKind = 28;
574             jjmatchedPos = 4;
575          }
576          return jjMoveStringLiteralDfa5_0(active0, 0x21000000L);
577       case 110:
578          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
579       case 114:
580          if ((active0 & 0x4000000000000L) != 0L)
581             return jjStartNfaWithStates_0(4, 50, 28);
582          return jjMoveStringLiteralDfa5_0(active0, 0x804800001000L);
583       case 115:
584          if ((active0 & 0x80000L) != 0L)
585             return jjStartNfaWithStates_0(4, 19, 28);
586          return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L);
587       case 116:
588          if ((active0 & 0x100000L) != 0L)
589             return jjStartNfaWithStates_0(4, 20, 28);
590          else if ((active0 & 0x40000000L) != 0L)
591             return jjStartNfaWithStates_0(4, 30, 28);
592          else if ((active0 & 0x1000000000000L) != 0L)
593             return jjStartNfaWithStates_0(4, 48, 28);
594          return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L);
595       case 117:
596          return jjMoveStringLiteralDfa5_0(active0, 0x400000L);
597       case 118:
598          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
599       case 119:
600          if ((active0 & 0x40000000000000L) != 0L)
601          {
602             jjmatchedKind = 54;
603             jjmatchedPos = 4;
604          }
605          return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L);
606       default :
607          break;
608    }
609    return jjStartNfa_0(3, active0, 0L);
610 }
611 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
612 {
613    if (((active0 &= old0)) == 0L)
614       return jjStartNfa_0(3, old0, 0L);
615    try { curChar = input_stream.readChar(); }
616    catch(java.io.IOException e) {
617       jjStopStringLiteralDfa_0(4, active0, 0L);
618       return 5;
619    }
620    switch(curChar)
621    {
622       case 97:
623          return jjMoveStringLiteralDfa6_0(active0, 0x3000L);
624       case 99:
625          if ((active0 & 0x400000000000L) != 0L)
626             return jjStartNfaWithStates_0(5, 46, 28);
627          else if ((active0 & 0x2000000000000L) != 0L)
628             return jjStartNfaWithStates_0(5, 49, 28);
629          return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
630       case 100:
631          return jjMoveStringLiteralDfa6_0(active0, 0x4000000L);
632       case 101:
633          if ((active0 & 0x1000000L) != 0L)
634             return jjStartNfaWithStates_0(5, 24, 28);
635          else if ((active0 & 0x10000000000L) != 0L)
636             return jjStartNfaWithStates_0(5, 40, 28);
637          break;
638       case 102:
639          return jjMoveStringLiteralDfa6_0(active0, 0x4000000000L);
640       case 103:
641          return jjMoveStringLiteralDfa6_0(active0, 0x80000000000L);
642       case 104:
643          if ((active0 & 0x8000000000000L) != 0L)
644             return jjStartNfaWithStates_0(5, 51, 28);
645          break;
646       case 105:
647          return jjMoveStringLiteralDfa6_0(active0, 0x1100000000000000L);
648       case 108:
649          return jjMoveStringLiteralDfa6_0(active0, 0x20400000L);
650       case 109:
651          return jjMoveStringLiteralDfa6_0(active0, 0x400000000L);
652       case 110:
653          if ((active0 & 0x800000000000L) != 0L)
654             return jjStartNfaWithStates_0(5, 47, 28);
655          return jjMoveStringLiteralDfa6_0(active0, 0x1000200000L);
656       case 114:
657          return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
658       case 115:
659          if ((active0 & 0x80000000000000L) != 0L)
660             return jjStartNfaWithStates_0(5, 55, 28);
661          break;
662       case 116:
663          if ((active0 & 0x800000000L) != 0L)
664             return jjStartNfaWithStates_0(5, 35, 28);
665          return jjMoveStringLiteralDfa6_0(active0, 0x4000100000000000L);
666       default :
667          break;
668    }
669    return jjStartNfa_0(4, active0, 0L);
670 }
671 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
672 {
673    if (((active0 &= old0)) == 0L)
674       return jjStartNfa_0(4, old0, 0L);
675    try { curChar = input_stream.readChar(); }
676    catch(java.io.IOException e) {
677       jjStopStringLiteralDfa_0(5, active0, 0L);
678       return 6;
679    }
680    switch(curChar)
681    {
682       case 97:
683          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000L);
684       case 99:
685          return jjMoveStringLiteralDfa7_0(active0, 0x1000001000L);
686       case 101:
687          if ((active0 & 0x80000000000L) != 0L)
688             return jjStartNfaWithStates_0(6, 43, 28);
689          else if ((active0 & 0x100000000000L) != 0L)
690             return jjStartNfaWithStates_0(6, 44, 28);
691          return jjMoveStringLiteralDfa7_0(active0, 0x100000400000000L);
692       case 102:
693          return jjMoveStringLiteralDfa7_0(active0, 0x4000000000000000L);
694       case 108:
695          return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000000L);
696       case 110:
697          if ((active0 & 0x2000L) != 0L)
698             return jjStartNfaWithStates_0(6, 13, 28);
699          break;
700       case 111:
701          return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
702       case 115:
703          if ((active0 & 0x4000000L) != 0L)
704             return jjStartNfaWithStates_0(6, 26, 28);
705          break;
706       case 116:
707          if ((active0 & 0x400000L) != 0L)
708             return jjStartNfaWithStates_0(6, 22, 28);
709          return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);
710       case 117:
711          return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
712       case 121:
713          if ((active0 & 0x20000000L) != 0L)
714             return jjStartNfaWithStates_0(6, 29, 28);
715          break;
716       default :
717          break;
718    }
719    return jjStartNfa_0(5, active0, 0L);
720 }
721 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
722 {
723    if (((active0 &= old0)) == 0L)
724       return jjStartNfa_0(5, old0, 0L);
725    try { curChar = input_stream.readChar(); }
726    catch(java.io.IOException e) {
727       jjStopStringLiteralDfa_0(6, active0, 0L);
728       return 7;
729    }
730    switch(curChar)
731    {
732       case 99:
733          return jjMoveStringLiteralDfa8_0(active0, 0x4000000000L);
734       case 101:
735          if ((active0 & 0x200000L) != 0L)
736             return jjStartNfaWithStates_0(7, 21, 28);
737          else if ((active0 & 0x1000000000000000L) != 0L)
738             return jjStartNfaWithStates_0(7, 60, 28);
739          return jjMoveStringLiteralDfa8_0(active0, 0x201000000000L);
740       case 110:
741          return jjMoveStringLiteralDfa8_0(active0, 0x110000400000000L);
742       case 112:
743          if ((active0 & 0x4000000000000000L) != 0L)
744             return jjStartNfaWithStates_0(7, 62, 28);
745          break;
746       case 116:
747          if ((active0 & 0x1000L) != 0L)
748             return jjStartNfaWithStates_0(7, 12, 28);
749          break;
750       default :
751          break;
752    }
753    return jjStartNfa_0(6, active0, 0L);
754 }
755 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
756 {
757    if (((active0 &= old0)) == 0L)
758       return jjStartNfa_0(6, old0, 0L);
759    try { curChar = input_stream.readChar(); }
760    catch(java.io.IOException e) {
761       jjStopStringLiteralDfa_0(7, active0, 0L);
762       return 8;
763    }
764    switch(curChar)
765    {
766       case 100:
767          if ((active0 & 0x200000000000L) != 0L)
768             return jjStartNfaWithStates_0(8, 45, 28);
769          break;
770       case 101:
771          if ((active0 & 0x4000000000L) != 0L)
772             return jjStartNfaWithStates_0(8, 38, 28);
773          break;
774       case 105:
775          return jjMoveStringLiteralDfa9_0(active0, 0x10000000000000L);
776       case 111:
777          return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
778       case 116:
779          if ((active0 & 0x100000000000000L) != 0L)
780             return jjStartNfaWithStates_0(8, 56, 28);
781          return jjMoveStringLiteralDfa9_0(active0, 0x400000000L);
782       default :
783          break;
784    }
785    return jjStartNfa_0(7, active0, 0L);
786 }
787 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
788 {
789    if (((active0 &= old0)) == 0L)
790       return jjStartNfa_0(7, old0, 0L);
791    try { curChar = input_stream.readChar(); }
792    catch(java.io.IOException e) {
793       jjStopStringLiteralDfa_0(8, active0, 0L);
794       return 9;
795    }
796    switch(curChar)
797    {
798       case 102:
799          if ((active0 & 0x1000000000L) != 0L)
800             return jjStartNfaWithStates_0(9, 36, 28);
801          break;
802       case 115:
803          if ((active0 & 0x400000000L) != 0L)
804             return jjStartNfaWithStates_0(9, 34, 28);
805          break;
806       case 122:
807          return jjMoveStringLiteralDfa10_0(active0, 0x10000000000000L);
808       default :
809          break;
810    }
811    return jjStartNfa_0(8, active0, 0L);
812 }
813 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
814 {
815    if (((active0 &= old0)) == 0L)
816       return jjStartNfa_0(8, old0, 0L);
817    try { curChar = input_stream.readChar(); }
818    catch(java.io.IOException e) {
819       jjStopStringLiteralDfa_0(9, active0, 0L);
820       return 10;
821    }
822    switch(curChar)
823    {
824       case 101:
825          return jjMoveStringLiteralDfa11_0(active0, 0x10000000000000L);
826       default :
827          break;
828    }
829    return jjStartNfa_0(9, active0, 0L);
830 }
831 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
832 {
833    if (((active0 &= old0)) == 0L)
834       return jjStartNfa_0(9, old0, 0L);
835    try { curChar = input_stream.readChar(); }
836    catch(java.io.IOException e) {
837       jjStopStringLiteralDfa_0(10, active0, 0L);
838       return 11;
839    }
840    switch(curChar)
841    {
842       case 100:
843          if ((active0 & 0x10000000000000L) != 0L)
844             return jjStartNfaWithStates_0(11, 52, 28);
845          break;
846       default :
847          break;
848    }
849    return jjStartNfa_0(10, active0, 0L);
850 }
851 private final void jjCheckNAdd(int state)
852 {
853    if (jjrounds[state] != jjround)
854    {
855       jjstateSet[jjnewStateCnt++] = state;
856       jjrounds[state] = jjround;
857    }
858 }
859 private final void jjAddStates(int start, int end)
860 {
861    do {
862       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
863    } while (start++ != end);
864 }
865 private final void jjCheckNAddTwoStates(int state1, int state2)
866 {
867    jjCheckNAdd(state1);
868    jjCheckNAdd(state2);
869 }
870 private final void jjCheckNAddStates(int start, int end)
871 {
872    do {
873       jjCheckNAdd(jjnextStates[start]);
874    } while (start++ != end);
875 }
876 private final void jjCheckNAddStates(int start)
877 {
878    jjCheckNAdd(jjnextStates[start]);
879    jjCheckNAdd(jjnextStates[start + 1]);
880 }
881 static final long[] jjbitVec0 = {
882    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
883 };
884 static final long[] jjbitVec2 = {
885    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
886 };
887 static final long[] jjbitVec3 = {
888    0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL
889 };
890 static final long[] jjbitVec4 = {
891    0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
892 };
893 static final long[] jjbitVec5 = {
894    0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
895 };
896 static final long[] jjbitVec6 = {
897    0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
898 };
899 static final long[] jjbitVec7 = {
900    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
901 };
902 static final long[] jjbitVec8 = {
903    0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
904 };
905 static final long[] jjbitVec9 = {
906    0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
907 };
908 static final long[] jjbitVec10 = {
909    0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
910 };
911 static final long[] jjbitVec11 = {
912    0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L
913 };
914 static final long[] jjbitVec12 = {
915    0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
916 };
917 static final long[] jjbitVec13 = {
918    0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
919 };
920 static final long[] jjbitVec14 = {
921    0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
922 };
923 static final long[] jjbitVec15 = {
924    0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
925 };
926 static final long[] jjbitVec16 = {
927    0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL
928 };
929 static final long[] jjbitVec17 = {
930    0x1L, 0x7fffffffeffL, 0xf00L, 0x0L
931 };
932 static final long[] jjbitVec18 = {
933    0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
934 };
935 static final long[] jjbitVec19 = {
936    0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
937 };
938 static final long[] jjbitVec20 = {
939    0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
940 };
941 static final long[] jjbitVec21 = {
942    0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
943 };
944 static final long[] jjbitVec22 = {
945    0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
946 };
947 static final long[] jjbitVec23 = {
948    0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L
949 };
950 static final long[] jjbitVec24 = {
951    0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
952 };
953 static final long[] jjbitVec25 = {
954    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
955 };
956 static final long[] jjbitVec26 = {
957    0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
958 };
959 static final long[] jjbitVec27 = {
960    0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L
961 };
962 static final long[] jjbitVec28 = {
963    0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
964 };
965 static final long[] jjbitVec29 = {
966    0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL
967 };
968 static final long[] jjbitVec30 = {
969    0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
970 };
971 static final long[] jjbitVec31 = {
972    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
973 };
974 static final long[] jjbitVec32 = {
975    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
976 };
977 static final long[] jjbitVec33 = {
978    0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
979 };
980 static final long[] jjbitVec34 = {
981    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
982 };
983 static final long[] jjbitVec35 = {
984    0x3fffffffffffL, 0x0L, 0x0L, 0x0L
985 };
986 static final long[] jjbitVec36 = {
987    0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
988 };
989 static final long[] jjbitVec37 = {
990    0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
991 };
992 static final long[] jjbitVec38 = {
993    0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
994 };
995 static final long[] jjbitVec39 = {
996    0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
997 };
998 static final long[] jjbitVec40 = {
999    0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL
1000 };
1001 static final long[] jjbitVec41 = {
1002    0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
1003 };
1004 static final long[] jjbitVec42 = {
1005    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
1006 };
1007 static final long[] jjbitVec43 = {
1008    0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
1009 };
1010 static final long[] jjbitVec44 = {
1011    0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
1012 };
1013 static final long[] jjbitVec45 = {
1014    0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
1015 };
1016 static final long[] jjbitVec46 = {
1017    0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL
1018 };
1019 static final long[] jjbitVec47 = {
1020    0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
1021 };
1022 static final long[] jjbitVec48 = {
1023    0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
1024 };
1025 static final long[] jjbitVec49 = {
1026    0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
1027 };
1028 static final long[] jjbitVec50 = {
1029    0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
1030 };
1031 static final long[] jjbitVec51 = {
1032    0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL
1033 };
1034 static final long[] jjbitVec52 = {
1035    0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L
1036 };
1037 static final long[] jjbitVec53 = {
1038    0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
1039 };
1040 static final long[] jjbitVec54 = {
1041    0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
1042 };
1043 static final long[] jjbitVec55 = {
1044    0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL
1045 };
1046 static final long[] jjbitVec56 = {
1047    0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
1048 };
1049 static final long[] jjbitVec57 = {
1050    0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L
1051 };
1052 static final long[] jjbitVec58 = {
1053    0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
1054 };
1055 static final long[] jjbitVec59 = {
1056    0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1057 };
1058 static final long[] jjbitVec60 = {
1059    0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
1060 };
1061 static final long[] jjbitVec61 = {
1062    0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
1063 };
1064 private final int jjMoveNfa_0(int startState, int curPos)
1065 {
1066    int[] nextStates;
1067    int startsAt = 0;
1068    jjnewStateCnt = 57;
1069    int i = 1;
1070    jjstateSet[0] = startState;
1071    int j, kind = 0x7fffffff;
1072    for (;;)
1073    {
1074       if (++jjround == 0x7fffffff)
1075          ReInitRounds();
1076       if (curChar < 64)
1077       {
1078          long l = 1L << curChar;
1079          MatchLoop: do
1080          {
1081             switch(jjstateSet[--i])
1082             {
1083                case 49:
1084                   if (curChar == 42)
1085                      jjstateSet[jjnewStateCnt++] = 54;
1086                   else if (curChar == 47)
1087                   {
1088                      if (kind > 6)
1089                         kind = 6;
1090                      jjCheckNAddStates(0, 2);
1091                   }
1092                   break;
1093                case 0:
1094                   if ((0x3ff000000000000L & l) != 0L)
1095                      jjCheckNAddStates(3, 9);
1096                   else if (curChar == 47)
1097                      jjAddStates(10, 11);
1098                   else if (curChar == 36)
1099                   {
1100                      if (kind > 71)
1101                         kind = 71;
1102                      jjCheckNAdd(28);
1103                   }
1104                   else if (curChar == 34)
1105                      jjCheckNAddStates(12, 14);
1106                   else if (curChar == 39)
1107                      jjAddStates(15, 16);
1108                   else if (curChar == 46)
1109                      jjCheckNAdd(4);
1110                   if ((0x3fe000000000000L & l) != 0L)
1111                   {
1112                      if (kind > 63)
1113                         kind = 63;
1114                      jjCheckNAddTwoStates(1, 2);
1115                   }
1116                   else if (curChar == 48)
1117                   {
1118                      if (kind > 63)
1119                         kind = 63;
1120                      jjCheckNAddStates(17, 19);
1121                   }
1122                   break;
1123                case 1:
1124                   if ((0x3ff000000000000L & l) == 0L)
1125                      break;
1126                   if (kind > 63)
1127                      kind = 63;
1128                   jjCheckNAddTwoStates(1, 2);
1129                   break;
1130                case 3:
1131                   if (curChar == 46)
1132                      jjCheckNAdd(4);
1133                   break;
1134                case 4:
1135                   if ((0x3ff000000000000L & l) == 0L)
1136                      break;
1137                   if (kind > 67)
1138                      kind = 67;
1139                   jjCheckNAddStates(20, 22);
1140                   break;
1141                case 6:
1142                   if ((0x280000000000L & l) != 0L)
1143                      jjCheckNAdd(7);
1144                   break;
1145                case 7:
1146                   if ((0x3ff000000000000L & l) == 0L)
1147                      break;
1148                   if (kind > 67)
1149                      kind = 67;
1150                   jjCheckNAddTwoStates(7, 8);
1151                   break;
1152                case 9:
1153                   if (curChar == 39)
1154                      jjAddStates(15, 16);
1155                   break;
1156                case 10:
1157                   if ((0xffffff7fffffdbffL & l) != 0L)
1158                      jjCheckNAdd(11);
1159                   break;
1160                case 11:
1161                   if (curChar == 39 && kind > 69)
1162                      kind = 69;
1163                   break;
1164                case 13:
1165                   if ((0x8400000000L & l) != 0L)
1166                      jjCheckNAdd(11);
1167                   break;
1168                case 14:
1169                   if ((0xff000000000000L & l) != 0L)
1170                      jjCheckNAddTwoStates(15, 11);
1171                   break;
1172                case 15:
1173                   if ((0xff000000000000L & l) != 0L)
1174                      jjCheckNAdd(11);
1175                   break;
1176                case 16:
1177                   if ((0xf000000000000L & l) != 0L)
1178                      jjstateSet[jjnewStateCnt++] = 17;
1179                   break;
1180                case 17:
1181                   if ((0xff000000000000L & l) != 0L)
1182                      jjCheckNAdd(15);
1183                   break;
1184                case 18:
1185                   if (curChar == 34)
1186                      jjCheckNAddStates(12, 14);
1187                   break;
1188                case 19:
1189                   if ((0xfffffffbffffdbffL & l) != 0L)
1190                      jjCheckNAddStates(12, 14);
1191                   break;
1192                case 21:
1193                   if ((0x8400000000L & l) != 0L)
1194                      jjCheckNAddStates(12, 14);
1195                   break;
1196                case 22:
1197                   if (curChar == 34 && kind > 70)
1198                      kind = 70;
1199                   break;
1200                case 23:
1201                   if ((0xff000000000000L & l) != 0L)
1202                      jjCheckNAddStates(23, 26);
1203                   break;
1204                case 24:
1205                   if ((0xff000000000000L & l) != 0L)
1206                      jjCheckNAddStates(12, 14);
1207                   break;
1208                case 25:
1209                   if ((0xf000000000000L & l) != 0L)
1210                      jjstateSet[jjnewStateCnt++] = 26;
1211                   break;
1212                case 26:
1213                   if ((0xff000000000000L & l) != 0L)
1214                      jjCheckNAdd(24);
1215                   break;
1216                case 27:
1217                   if (curChar != 36)
1218                      break;
1219                   if (kind > 71)
1220                      kind = 71;
1221                   jjCheckNAdd(28);
1222                   break;
1223                case 28:
1224                   if ((0x3ff00100fffc1ffL & l) == 0L)
1225                      break;
1226                   if (kind > 71)
1227                      kind = 71;
1228                   jjCheckNAdd(28);
1229                   break;
1230                case 29:
1231                   if ((0x3ff000000000000L & l) != 0L)
1232                      jjCheckNAddStates(3, 9);
1233                   break;
1234                case 30:
1235                   if ((0x3ff000000000000L & l) != 0L)
1236                      jjCheckNAddTwoStates(30, 31);
1237                   break;
1238                case 31:
1239                   if (curChar != 46)
1240                      break;
1241                   if (kind > 67)
1242                      kind = 67;
1243                   jjCheckNAddStates(27, 29);
1244                   break;
1245                case 32:
1246                   if ((0x3ff000000000000L & l) == 0L)
1247                      break;
1248                   if (kind > 67)
1249                      kind = 67;
1250                   jjCheckNAddStates(27, 29);
1251                   break;
1252                case 34:
1253                   if ((0x280000000000L & l) != 0L)
1254                      jjCheckNAdd(35);
1255                   break;
1256                case 35:
1257                   if ((0x3ff000000000000L & l) == 0L)
1258                      break;
1259                   if (kind > 67)
1260                      kind = 67;
1261                   jjCheckNAddTwoStates(35, 8);
1262                   break;
1263                case 36:
1264                   if ((0x3ff000000000000L & l) != 0L)
1265                      jjCheckNAddTwoStates(36, 37);
1266                   break;
1267                case 38:
1268                   if ((0x280000000000L & l) != 0L)
1269                      jjCheckNAdd(39);
1270                   break;
1271                case 39:
1272                   if ((0x3ff000000000000L & l) == 0L)
1273                      break;
1274                   if (kind > 67)
1275                      kind = 67;
1276                   jjCheckNAddTwoStates(39, 8);
1277                   break;
1278                case 40:
1279                   if ((0x3ff000000000000L & l) != 0L)
1280                      jjCheckNAddStates(30, 32);
1281                   break;
1282                case 42:
1283                   if ((0x280000000000L & l) != 0L)
1284                      jjCheckNAdd(43);
1285                   break;
1286                case 43:
1287                   if ((0x3ff000000000000L & l) != 0L)
1288                      jjCheckNAddTwoStates(43, 8);
1289                   break;
1290                case 44:
1291                   if (curChar != 48)
1292                      break;
1293                   if (kind > 63)
1294                      kind = 63;
1295                   jjCheckNAddStates(17, 19);
1296                   break;
1297                case 46:
1298                   if ((0x3ff000000000000L & l) == 0L)
1299                      break;
1300                   if (kind > 63)
1301                      kind = 63;
1302                   jjCheckNAddTwoStates(46, 2);
1303                   break;
1304                case 47:
1305                   if ((0xff000000000000L & l) == 0L)
1306                      break;
1307                   if (kind > 63)
1308                      kind = 63;
1309                   jjCheckNAddTwoStates(47, 2);
1310                   break;
1311                case 48:
1312                   if (curChar == 47)
1313                      jjAddStates(10, 11);
1314                   break;
1315                case 50:
1316                   if ((0xffffffffffffdbffL & l) == 0L)
1317                      break;
1318                   if (kind > 6)
1319                      kind = 6;
1320                   jjCheckNAddStates(0, 2);
1321                   break;
1322                case 51:
1323                   if ((0x2400L & l) != 0L && kind > 6)
1324                      kind = 6;
1325                   break;
1326                case 52:
1327                   if (curChar == 10 && kind > 6)
1328                      kind = 6;
1329                   break;
1330                case 53:
1331                   if (curChar == 13)
1332                      jjstateSet[jjnewStateCnt++] = 52;
1333                   break;
1334                case 54:
1335                   if (curChar == 42)
1336                      jjstateSet[jjnewStateCnt++] = 55;
1337                   break;
1338                case 55:
1339                   if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1340                      kind = 7;
1341                   break;
1342                case 56:
1343                   if (curChar == 42)
1344                      jjstateSet[jjnewStateCnt++] = 54;
1345                   break;
1346                default : break;
1347             }
1348          } while(i != startsAt);
1349       }
1350       else if (curChar < 128)
1351       {
1352          long l = 1L << (curChar & 077);
1353          MatchLoop: do
1354          {
1355             switch(jjstateSet[--i])
1356             {
1357                case 0:
1358                   if ((0x7fffffe87fffffeL & l) == 0L)
1359                      break;
1360                   if (kind > 71)
1361                      kind = 71;
1362                   jjCheckNAdd(28);
1363                   break;
1364                case 2:
1365                   if ((0x100000001000L & l) != 0L && kind > 63)
1366                      kind = 63;
1367                   break;
1368                case 5:
1369                   if ((0x2000000020L & l) != 0L)
1370                      jjAddStates(33, 34);
1371                   break;
1372                case 8:
1373                   if ((0x5000000050L & l) != 0L && kind > 67)
1374                      kind = 67;
1375                   break;
1376                case 10:
1377                   if ((0xffffffffefffffffL & l) != 0L)
1378                      jjCheckNAdd(11);
1379                   break;
1380                case 12:
1381                   if (curChar == 92)
1382                      jjAddStates(35, 37);
1383                   break;
1384                case 13:
1385                   if ((0x14404410000000L & l) != 0L)
1386                      jjCheckNAdd(11);
1387                   break;
1388                case 19:
1389                   if ((0xffffffffefffffffL & l) != 0L)
1390                      jjCheckNAddStates(12, 14);
1391                   break;
1392                case 20:
1393                   if (curChar == 92)
1394                      jjAddStates(38, 40);
1395                   break;
1396                case 21:
1397                   if ((0x14404410000000L & l) != 0L)
1398                      jjCheckNAddStates(12, 14);
1399                   break;
1400                case 28:
1401                   if ((0x87fffffe87fffffeL & l) == 0L)
1402                      break;
1403                   if (kind > 71)
1404                      kind = 71;
1405                   jjCheckNAdd(28);
1406                   break;
1407                case 33:
1408                   if ((0x2000000020L & l) != 0L)
1409                      jjAddStates(41, 42);
1410                   break;
1411                case 37:
1412                   if ((0x2000000020L & l) != 0L)
1413                      jjAddStates(43, 44);
1414                   break;
1415                case 41:
1416                   if ((0x2000000020L & l) != 0L)
1417                      jjAddStates(45, 46);
1418                   break;
1419                case 45:
1420                   if ((0x100000001000000L & l) != 0L)
1421                      jjCheckNAdd(46);
1422                   break;
1423                case 46:
1424                   if ((0x7e0000007eL & l) == 0L)
1425                      break;
1426                   if (kind > 63)
1427                      kind = 63;
1428                   jjCheckNAddTwoStates(46, 2);
1429                   break;
1430                case 50:
1431                   if (kind > 6)
1432                      kind = 6;
1433                   jjAddStates(0, 2);
1434                   break;
1435                case 55:
1436                   if (kind > 7)
1437                      kind = 7;
1438                   break;
1439                default : break;
1440             }
1441          } while(i != startsAt);
1442       }
1443       else
1444       {
1445          int hiByte = (int)(curChar >> 8);
1446          int i1 = hiByte >> 6;
1447          long l1 = 1L << (hiByte & 077);
1448          int i2 = (curChar & 0xff) >> 6;
1449          long l2 = 1L << (curChar & 077);
1450          MatchLoop: do
1451          {
1452             switch(jjstateSet[--i])
1453             {
1454                case 0:
1455                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1456                      break;
1457                   if (kind > 71)
1458                      kind = 71;
1459                   jjCheckNAdd(28);
1460                   break;
1461                case 10:
1462                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1463                      jjstateSet[jjnewStateCnt++] = 11;
1464                   break;
1465                case 19:
1466                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1467                      jjAddStates(12, 14);
1468                   break;
1469                case 28:
1470                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1471                      break;
1472                   if (kind > 71)
1473                      kind = 71;
1474                   jjCheckNAdd(28);
1475                   break;
1476                case 50:
1477                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1478                      break;
1479                   if (kind > 6)
1480                      kind = 6;
1481                   jjAddStates(0, 2);
1482                   break;
1483                case 55:
1484                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
1485                      kind = 7;
1486                   break;
1487                default : break;
1488             }
1489          } while(i != startsAt);
1490       }
1491       if (kind != 0x7fffffff)
1492       {
1493          jjmatchedKind = kind;
1494          jjmatchedPos = curPos;
1495          kind = 0x7fffffff;
1496       }
1497       ++curPos;
1498       if ((i = jjnewStateCnt) == (startsAt = 57 - (jjnewStateCnt = startsAt)))
1499          return curPos;
1500       try { curChar = input_stream.readChar(); }
1501       catch(java.io.IOException e) { return curPos; }
1502    }
1503 }
1504 private final int jjMoveStringLiteralDfa0_2()
1505 {
1506    switch(curChar)
1507    {
1508       case 42:
1509          return jjMoveStringLiteralDfa1_2(0x400L);
1510       default :
1511          return 1;
1512    }
1513 }
1514 private final int jjMoveStringLiteralDfa1_2(long active0)
1515 {
1516    try { curChar = input_stream.readChar(); }
1517    catch(java.io.IOException e) {
1518       return 1;
1519    }
1520    switch(curChar)
1521    {
1522       case 47:
1523          if ((active0 & 0x400L) != 0L)
1524             return jjStopAtPos(1, 10);
1525          break;
1526       default :
1527          return 2;
1528    }
1529    return 2;
1530 }
1531 private final int jjMoveStringLiteralDfa0_1()
1532 {
1533    switch(curChar)
1534    {
1535       case 42:
1536          return jjMoveStringLiteralDfa1_1(0x200L);
1537       default :
1538          return 1;
1539    }
1540 }
1541 private final int jjMoveStringLiteralDfa1_1(long active0)
1542 {
1543    try { curChar = input_stream.readChar(); }
1544    catch(java.io.IOException e) {
1545       return 1;
1546    }
1547    switch(curChar)
1548    {
1549       case 47:
1550          if ((active0 & 0x200L) != 0L)
1551             return jjStopAtPos(1, 9);
1552          break;
1553       default :
1554          return 2;
1555    }
1556    return 2;
1557 }
1558 static final int[] jjnextStates = {
1559    50, 51, 53, 30, 31, 36, 37, 40, 41, 8, 49, 56, 19, 20, 22, 10, 
1560    12, 45, 47, 2, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 40, 41, 
1561    8, 6, 7, 13, 14, 16, 21, 23, 25, 34, 35, 38, 39, 42, 43, 
1562 };
1563 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1564 {
1565    switch(hiByte)
1566    {
1567       case 0:
1568          return ((jjbitVec2[i2] & l2) != 0L);
1569       default : 
1570          if ((jjbitVec0[i1] & l1) != 0L)
1571             return true;
1572          return false;
1573    }
1574 }
1575 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1576 {
1577    switch(hiByte)
1578    {
1579       case 0:
1580          return ((jjbitVec4[i2] & l2) != 0L);
1581       case 2:
1582          return ((jjbitVec5[i2] & l2) != 0L);
1583       case 3:
1584          return ((jjbitVec6[i2] & l2) != 0L);
1585       case 4:
1586          return ((jjbitVec7[i2] & l2) != 0L);
1587       case 5:
1588          return ((jjbitVec8[i2] & l2) != 0L);
1589       case 6:
1590          return ((jjbitVec9[i2] & l2) != 0L);
1591       case 7:
1592          return ((jjbitVec10[i2] & l2) != 0L);
1593       case 9:
1594          return ((jjbitVec11[i2] & l2) != 0L);
1595       case 10:
1596          return ((jjbitVec12[i2] & l2) != 0L);
1597       case 11:
1598          return ((jjbitVec13[i2] & l2) != 0L);
1599       case 12:
1600          return ((jjbitVec14[i2] & l2) != 0L);
1601       case 13:
1602          return ((jjbitVec15[i2] & l2) != 0L);
1603       case 14:
1604          return ((jjbitVec16[i2] & l2) != 0L);
1605       case 15:
1606          return ((jjbitVec17[i2] & l2) != 0L);
1607       case 16:
1608          return ((jjbitVec18[i2] & l2) != 0L);
1609       case 17:
1610          return ((jjbitVec19[i2] & l2) != 0L);
1611       case 18:
1612          return ((jjbitVec20[i2] & l2) != 0L);
1613       case 19:
1614          return ((jjbitVec21[i2] & l2) != 0L);
1615       case 20:
1616          return ((jjbitVec0[i2] & l2) != 0L);
1617       case 22:
1618          return ((jjbitVec22[i2] & l2) != 0L);
1619       case 23:
1620          return ((jjbitVec23[i2] & l2) != 0L);
1621       case 24:
1622          return ((jjbitVec24[i2] & l2) != 0L);
1623       case 30:
1624          return ((jjbitVec25[i2] & l2) != 0L);
1625       case 31:
1626          return ((jjbitVec26[i2] & l2) != 0L);
1627       case 32:
1628          return ((jjbitVec27[i2] & l2) != 0L);
1629       case 33:
1630          return ((jjbitVec28[i2] & l2) != 0L);
1631       case 48:
1632          return ((jjbitVec29[i2] & l2) != 0L);
1633       case 49:
1634          return ((jjbitVec30[i2] & l2) != 0L);
1635       case 77:
1636          return ((jjbitVec31[i2] & l2) != 0L);
1637       case 159:
1638          return ((jjbitVec32[i2] & l2) != 0L);
1639       case 164:
1640          return ((jjbitVec33[i2] & l2) != 0L);
1641       case 215:
1642          return ((jjbitVec34[i2] & l2) != 0L);
1643       case 250:
1644          return ((jjbitVec35[i2] & l2) != 0L);
1645       case 251:
1646          return ((jjbitVec36[i2] & l2) != 0L);
1647       case 253:
1648          return ((jjbitVec37[i2] & l2) != 0L);
1649       case 254:
1650          return ((jjbitVec38[i2] & l2) != 0L);
1651       case 255:
1652          return ((jjbitVec39[i2] & l2) != 0L);
1653       default : 
1654          if ((jjbitVec3[i1] & l1) != 0L)
1655             return true;
1656          return false;
1657    }
1658 }
1659 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1660 {
1661    switch(hiByte)
1662    {
1663       case 0:
1664          return ((jjbitVec40[i2] & l2) != 0L);
1665       case 2:
1666          return ((jjbitVec5[i2] & l2) != 0L);
1667       case 3:
1668          return ((jjbitVec41[i2] & l2) != 0L);
1669       case 4:
1670          return ((jjbitVec42[i2] & l2) != 0L);
1671       case 5:
1672          return ((jjbitVec43[i2] & l2) != 0L);
1673       case 6:
1674          return ((jjbitVec44[i2] & l2) != 0L);
1675       case 7:
1676          return ((jjbitVec45[i2] & l2) != 0L);
1677       case 9:
1678          return ((jjbitVec46[i2] & l2) != 0L);
1679       case 10:
1680          return ((jjbitVec47[i2] & l2) != 0L);
1681       case 11:
1682          return ((jjbitVec48[i2] & l2) != 0L);
1683       case 12:
1684          return ((jjbitVec49[i2] & l2) != 0L);
1685       case 13:
1686          return ((jjbitVec50[i2] & l2) != 0L);
1687       case 14:
1688          return ((jjbitVec51[i2] & l2) != 0L);
1689       case 15:
1690          return ((jjbitVec52[i2] & l2) != 0L);
1691       case 16:
1692          return ((jjbitVec53[i2] & l2) != 0L);
1693       case 17:
1694          return ((jjbitVec19[i2] & l2) != 0L);
1695       case 18:
1696          return ((jjbitVec20[i2] & l2) != 0L);
1697       case 19:
1698          return ((jjbitVec54[i2] & l2) != 0L);
1699       case 20:
1700          return ((jjbitVec0[i2] & l2) != 0L);
1701       case 22:
1702          return ((jjbitVec22[i2] & l2) != 0L);
1703       case 23:
1704          return ((jjbitVec55[i2] & l2) != 0L);
1705       case 24:
1706          return ((jjbitVec56[i2] & l2) != 0L);
1707       case 30:
1708          return ((jjbitVec25[i2] & l2) != 0L);
1709       case 31:
1710          return ((jjbitVec26[i2] & l2) != 0L);
1711       case 32:
1712          return ((jjbitVec57[i2] & l2) != 0L);
1713       case 33:
1714          return ((jjbitVec28[i2] & l2) != 0L);
1715       case 48:
1716          return ((jjbitVec58[i2] & l2) != 0L);
1717       case 49:
1718          return ((jjbitVec30[i2] & l2) != 0L);
1719       case 77:
1720          return ((jjbitVec31[i2] & l2) != 0L);
1721       case 159:
1722          return ((jjbitVec32[i2] & l2) != 0L);
1723       case 164:
1724          return ((jjbitVec33[i2] & l2) != 0L);
1725       case 215:
1726          return ((jjbitVec34[i2] & l2) != 0L);
1727       case 250:
1728          return ((jjbitVec35[i2] & l2) != 0L);
1729       case 251:
1730          return ((jjbitVec59[i2] & l2) != 0L);
1731       case 253:
1732          return ((jjbitVec37[i2] & l2) != 0L);
1733       case 254:
1734          return ((jjbitVec60[i2] & l2) != 0L);
1735       case 255:
1736          return ((jjbitVec61[i2] & l2) != 0L);
1737       default : 
1738          if ((jjbitVec3[i1] & l1) != 0L)
1739             return true;
1740          return false;
1741    }
1742 }
1743 public static final String[] jjstrLiteralImages = {
1744 "", null, null, null, null, null, null, null, null, null, null, null, 
1745 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145", 
1746 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", 
1747 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", 
1748 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145", 
1749 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154", 
1750 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", 
1751 "\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", 
1752 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", 
1753 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145", 
1754 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 
1755 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162", 
1756 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", 
1757 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164", 
1758 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145", 
1759 "\167\150\151\154\145", "\163\164\162\151\143\164\146\160", null, null, null, null, null, null, null, 
1760 null, null, null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", 
1761 "\56", "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", 
1762 "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", 
1763 "\57", "\46", "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75", 
1764 "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", 
1765 "\76\76\76\75", "\56\56\56", "\76\76\76", "\76\76", "\76", "\32", "\176\133\135", };
1766 public static final String[] lexStateNames = {
1767    "DEFAULT", 
1768    "IN_FORMAL_COMMENT", 
1769    "IN_MULTI_LINE_COMMENT", 
1770 };
1771 public static final int[] jjnewLexState = {
1772    -1, -1, -1, -1, -1, -1, -1, 1, 2, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1773    -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, 
1774    -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, 
1775    -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, 
1776    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1777 };
1778 static final long[] jjtoToken = {
1779    0xfffffffffffff001L, 0xffffffffffffce8L, 
1780 };
1781 static final long[] jjtoSkip = {
1782    0x67eL, 0x0L, 
1783 };
1784 static final long[] jjtoSpecial = {
1785    0x67eL, 0x0L, 
1786 };
1787 static final long[] jjtoMore = {
1788    0x980L, 0x0L, 
1789 };
1790 protected CharStream input_stream;
1791 private final int[] jjrounds = new int[57];
1792 private final int[] jjstateSet = new int[114];
1793 StringBuffer image;
1794 int jjimageLen;
1795 int lengthOfMatch;
1796 protected char curChar;
1797 public JavaParserTokenManager(CharStream stream){
1798    input_stream = stream;
1799 }
1800 public JavaParserTokenManager(CharStream stream, int lexState){
1801    this(stream);
1802    SwitchTo(lexState);
1803 }
1804 public void ReInit(CharStream stream)
1805 {
1806    jjmatchedPos = jjnewStateCnt = 0;
1807    curLexState = defaultLexState;
1808    input_stream = stream;
1809    ReInitRounds();
1810 }
1811 private final void ReInitRounds()
1812 {
1813    int i;
1814    jjround = 0x80000001;
1815    for (i = 57; i-- > 0;)
1816       jjrounds[i] = 0x80000000;
1817 }
1818 public void ReInit(CharStream stream, int lexState)
1819 {
1820    ReInit(stream);
1821    SwitchTo(lexState);
1822 }
1823 public void SwitchTo(int lexState)
1824 {
1825    if (lexState >= 3 || lexState < 0)
1826       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1827    else
1828       curLexState = lexState;
1829 }
1830 
1831 protected Token jjFillToken()
1832 {
1833    Token t = Token.newToken(jjmatchedKind);
1834    t.kind = jjmatchedKind;
1835    String im = jjstrLiteralImages[jjmatchedKind];
1836    t.image = (im == null) ? input_stream.GetImage() : im;
1837    t.beginLine = input_stream.getBeginLine();
1838    t.beginColumn = input_stream.getBeginColumn();
1839    t.endLine = input_stream.getEndLine();
1840    t.endColumn = input_stream.getEndColumn();
1841    return t;
1842 }
1843 
1844 int curLexState = 0;
1845 int defaultLexState = 0;
1846 int jjnewStateCnt;
1847 int jjround;
1848 int jjmatchedPos;
1849 int jjmatchedKind;
1850 
1851 public Token getNextToken() 
1852 {
1853   int kind;
1854   Token specialToken = null;
1855   Token matchedToken;
1856   int curPos = 0;
1857 
1858   EOFLoop :
1859   for (;;)
1860   {   
1861    try   
1862    {     
1863       curChar = input_stream.BeginToken();
1864    }     
1865    catch(java.io.IOException e)
1866    {        
1867       jjmatchedKind = 0;
1868       matchedToken = jjFillToken();
1869       matchedToken.specialToken = specialToken;
1870       return matchedToken;
1871    }
1872    image = null;
1873    jjimageLen = 0;
1874 
1875    for (;;)
1876    {
1877      switch(curLexState)
1878      {
1879        case 0:
1880          jjmatchedKind = 0x7fffffff;
1881          jjmatchedPos = 0;
1882          curPos = jjMoveStringLiteralDfa0_0();
1883          break;
1884        case 1:
1885          jjmatchedKind = 0x7fffffff;
1886          jjmatchedPos = 0;
1887          curPos = jjMoveStringLiteralDfa0_1();
1888          if (jjmatchedPos == 0 && jjmatchedKind > 11)
1889          {
1890             jjmatchedKind = 11;
1891          }
1892          break;
1893        case 2:
1894          jjmatchedKind = 0x7fffffff;
1895          jjmatchedPos = 0;
1896          curPos = jjMoveStringLiteralDfa0_2();
1897          if (jjmatchedPos == 0 && jjmatchedKind > 11)
1898          {
1899             jjmatchedKind = 11;
1900          }
1901          break;
1902      }
1903      if (jjmatchedKind != 0x7fffffff)
1904      {
1905         if (jjmatchedPos + 1 < curPos)
1906            input_stream.backup(curPos - jjmatchedPos - 1);
1907         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1908         {
1909            matchedToken = jjFillToken();
1910            matchedToken.specialToken = specialToken;
1911            TokenLexicalActions(matchedToken);
1912        if (jjnewLexState[jjmatchedKind] != -1)
1913          curLexState = jjnewLexState[jjmatchedKind];
1914            return matchedToken;
1915         }
1916         else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1917         {
1918            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1919            {
1920               matchedToken = jjFillToken();
1921               if (specialToken == null)
1922                  specialToken = matchedToken;
1923               else
1924               {
1925                  matchedToken.specialToken = specialToken;
1926                  specialToken = (specialToken.next = matchedToken);
1927               }
1928               SkipLexicalActions(matchedToken);
1929            }
1930            else 
1931               SkipLexicalActions(null);
1932          if (jjnewLexState[jjmatchedKind] != -1)
1933            curLexState = jjnewLexState[jjmatchedKind];
1934            continue EOFLoop;
1935         }
1936         MoreLexicalActions();
1937       if (jjnewLexState[jjmatchedKind] != -1)
1938         curLexState = jjnewLexState[jjmatchedKind];
1939         curPos = 0;
1940         jjmatchedKind = 0x7fffffff;
1941         try {
1942            curChar = input_stream.readChar();
1943            continue;
1944         }
1945         catch (java.io.IOException e1) { }
1946      }
1947      int error_line = input_stream.getEndLine();
1948      int error_column = input_stream.getEndColumn();
1949      String error_after = null;
1950      boolean EOFSeen = false;
1951      try { input_stream.readChar(); input_stream.backup(1); }
1952      catch (java.io.IOException e1) {
1953         EOFSeen = true;
1954         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1955         if (curChar == '\n' || curChar == '\r') {
1956            error_line++;
1957            error_column = 0;
1958         }
1959         else
1960            error_column++;
1961      }
1962      if (!EOFSeen) {
1963         input_stream.backup(1);
1964         error_after = curPos <= 1 ? "" : input_stream.GetImage();
1965      }
1966      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1967    }
1968   }
1969 }
1970 
1971 void SkipLexicalActions(Token matchedToken)
1972 {
1973    switch(jjmatchedKind)
1974    {
1975       default :
1976          break;
1977    }
1978 }
1979 void MoreLexicalActions()
1980 {
1981    jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1982    switch(jjmatchedKind)
1983    {
1984       case 7 :
1985          if (image == null)
1986             image = new StringBuffer();
1987          image.append(input_stream.GetSuffix(jjimageLen));
1988          jjimageLen = 0;
1989                    input_stream.backup(1);
1990          break;
1991       default : 
1992          break;
1993    }
1994 }
1995 void TokenLexicalActions(Token matchedToken)
1996 {
1997    switch(jjmatchedKind)
1998    {
1999       case 119 :
2000         if (image == null)
2001             image = new StringBuffer();
2002             image.append(jjstrLiteralImages[119]);
2003      matchedToken.kind = GT;
2004      ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT;
2005      input_stream.backup(2);
2006      matchedToken.image = ">";
2007          break;
2008       case 120 :
2009         if (image == null)
2010             image = new StringBuffer();
2011             image.append(jjstrLiteralImages[120]);
2012      matchedToken.kind = GT;
2013      ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT;
2014      input_stream.backup(1);
2015      matchedToken.image = ">";
2016          break;
2017       default : 
2018          break;
2019    }
2020 }
2021 }