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