View Javadoc

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