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