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