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.
042package net.sourceforge.cobertura.javancss.parser.debug;
043import net.sourceforge.cobertura.javancss.parser.JavaParserInterface;
044import java.util.*;
045import net.sourceforge.cobertura.javancss.ccl.Util;
046import net.sourceforge.cobertura.javancss.FunctionMetric;
047import net.sourceforge.cobertura.javancss.ObjectMetric;
048import net.sourceforge.cobertura.javancss.PackageMetric;
049
050/** Token Manager. */
051public 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; }
065private 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}
189private final int jjStartNfa_0(int pos, long active0, long active1)
190{
191   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
192}
193private int jjStopAtPos(int pos, int kind)
194{
195   jjmatchedKind = kind;
196   jjmatchedPos = pos;
197   return pos + 1;
198}
199private 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}
302private 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}
418private 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}
489private 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}
565private 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}
637private 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}
699private 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}
749private 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}
783private 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}
815private 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}
841private 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}
859private 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}
879private 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}
887static final long[] jjbitVec0 = {
888   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
889};
890static final long[] jjbitVec2 = {
891   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
892};
893static final long[] jjbitVec3 = {
894   0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL
895};
896static final long[] jjbitVec4 = {
897   0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
898};
899static final long[] jjbitVec5 = {
900   0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
901};
902static final long[] jjbitVec6 = {
903   0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
904};
905static final long[] jjbitVec7 = {
906   0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
907};
908static final long[] jjbitVec8 = {
909   0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
910};
911static final long[] jjbitVec9 = {
912   0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
913};
914static final long[] jjbitVec10 = {
915   0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
916};
917static final long[] jjbitVec11 = {
918   0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L
919};
920static final long[] jjbitVec12 = {
921   0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
922};
923static final long[] jjbitVec13 = {
924   0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
925};
926static final long[] jjbitVec14 = {
927   0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
928};
929static final long[] jjbitVec15 = {
930   0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
931};
932static final long[] jjbitVec16 = {
933   0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL
934};
935static final long[] jjbitVec17 = {
936   0x1L, 0x7fffffffeffL, 0xf00L, 0x0L
937};
938static final long[] jjbitVec18 = {
939   0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
940};
941static final long[] jjbitVec19 = {
942   0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
943};
944static final long[] jjbitVec20 = {
945   0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
946};
947static final long[] jjbitVec21 = {
948   0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
949};
950static final long[] jjbitVec22 = {
951   0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
952};
953static final long[] jjbitVec23 = {
954   0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L
955};
956static final long[] jjbitVec24 = {
957   0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
958};
959static final long[] jjbitVec25 = {
960   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
961};
962static final long[] jjbitVec26 = {
963   0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
964};
965static final long[] jjbitVec27 = {
966   0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L
967};
968static final long[] jjbitVec28 = {
969   0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
970};
971static final long[] jjbitVec29 = {
972   0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL
973};
974static final long[] jjbitVec30 = {
975   0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
976};
977static final long[] jjbitVec31 = {
978   0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
979};
980static final long[] jjbitVec32 = {
981   0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
982};
983static final long[] jjbitVec33 = {
984   0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
985};
986static final long[] jjbitVec34 = {
987   0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
988};
989static final long[] jjbitVec35 = {
990   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
991};
992static final long[] jjbitVec36 = {
993   0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
994};
995static final long[] jjbitVec37 = {
996   0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
997};
998static final long[] jjbitVec38 = {
999   0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
1000};
1001static final long[] jjbitVec39 = {
1002   0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
1003};
1004static final long[] jjbitVec40 = {
1005   0x7fffffe00000000L, 0xfffe03ff000007ffL, 0xffffffffffffffffL, 0x1fff0060002fffffL
1006};
1007static final long[] jjbitVec41 = {
1008   0x23ffffffffffffe0L, 0xffc3ff010000L, 0x3c5fdfffff99fe0L, 0xfffc3b0000000L
1009};
1010static final long[] jjbitVec42 = {
1011   0x36dfdfffff987e0L, 0x1cffc05e000000L, 0x23edfdfffffbafe0L, 0xffc100010000L
1012};
1013static final long[] jjbitVec43 = {
1014   0x23cdfdfffff99fe0L, 0xffc3b0000000L, 0x3bfc718d63dc7e0L, 0xff8000000000L
1015};
1016static final long[] jjbitVec44 = {
1017   0x3effdfffffddfe0L, 0xffc300000000L, 0x3effdfffffddfe0L, 0xffc340000000L
1018};
1019static final long[] jjbitVec45 = {
1020   0x3fffdfffffddfe0L, 0xffc300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
1021};
1022static final long[] jjbitVec46 = {
1023   0x800dfffffffffffeL, 0x3ff007fL, 0x200decaefef02596L, 0x33ff005fL
1024};
1025static final long[] jjbitVec47 = {
1026   0x6fbffffffffL, 0x3f03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
1027};
1028private 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}
1394private final int jjStopStringLiteralDfa_2(int pos, long active0)
1395{
1396   switch (pos)
1397   {
1398      default :
1399         return -1;
1400   }
1401}
1402private final int jjStartNfa_2(int pos, long active0)
1403{
1404   return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
1405}
1406private 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}
1416private 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}
1434private 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}
1512private int jjMoveStringLiteralDfa0_1()
1513{
1514   return jjMoveNfa_1(4, 0);
1515}
1516private 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}
1623static 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};
1628private 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}
1640private 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}
1724private 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. */
1810public 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, 
1828null, 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. */
1836public static final String[] lexStateNames = {
1837   "DEFAULT",
1838   "IN_SINGLE_LINE_COMMENT",
1839   "IN_MULTI_LINE_COMMENT",
1840};
1841
1842/** Lex State array. */
1843public 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};
1850static final long[] jjtoToken = {
1851   0xffffffffffffe001L, 0x7ffffffffffe747L, 
1852};
1853static final long[] jjtoSkip = {
1854   0xf7eL, 0x0L, 
1855};
1856static final long[] jjtoSpecial = {
1857   0xf00L, 0x0L, 
1858};
1859static final long[] jjtoMore = {
1860   0x1080L, 0x0L, 
1861};
1862protected JavaCharStream input_stream;
1863private final int[] jjrounds = new int[48];
1864private final int[] jjstateSet = new int[96];
1865private final StringBuffer jjimage = new StringBuffer();
1866private StringBuffer image = jjimage;
1867private int jjimageLen;
1868private int lengthOfMatch;
1869protected char curChar;
1870/** Constructor. */
1871public 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. */
1878public JavaParserDebugTokenManager(JavaCharStream stream, int lexState){
1879   this(stream);
1880   SwitchTo(lexState);
1881}
1882
1883/** Reinitialise parser. */
1884public void ReInit(JavaCharStream stream)
1885{
1886   jjmatchedPos = jjnewStateCnt = 0;
1887   curLexState = defaultLexState;
1888   input_stream = stream;
1889   ReInitRounds();
1890}
1891private void ReInitRounds()
1892{
1893   int i;
1894   jjround = 0x80000001;
1895   for (i = 48; i-- > 0;)
1896      jjrounds[i] = 0x80000000;
1897}
1898
1899/** Reinitialise parser. */
1900public void ReInit(JavaCharStream stream, int lexState)
1901{
1902   ReInit(stream);
1903   SwitchTo(lexState);
1904}
1905
1906/** Switch to specified lex state. */
1907public 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
1915protected 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
1951int curLexState = 0;
1952int defaultLexState = 0;
1953int jjnewStateCnt;
1954int jjround;
1955int jjmatchedPos;
1956int jjmatchedKind;
1957
1958/** Get the next Token. */
1959public 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
2085void 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}
2105void 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}
2119private void jjCheckNAdd(int state)
2120{
2121   if (jjrounds[state] != jjround)
2122   {
2123      jjstateSet[jjnewStateCnt++] = state;
2124      jjrounds[state] = jjround;
2125   }
2126}
2127private void jjAddStates(int start, int end)
2128{
2129   do {
2130      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
2131   } while (start++ != end);
2132}
2133private void jjCheckNAddTwoStates(int state1, int state2)
2134{
2135   jjCheckNAdd(state1);
2136   jjCheckNAdd(state2);
2137}
2138
2139private void jjCheckNAddStates(int start, int end)
2140{
2141   do {
2142      jjCheckNAdd(jjnextStates[start]);
2143   } while (start++ != end);
2144}
2145
2146}