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