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