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