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