001    /*
002     * Cobertura - http://cobertura.sourceforge.net/
003     *
004     * This file was taken from JavaNCSS
005     * http://www.kclee.com/clemens/java/javancss/
006     * Copyright (C) 2000 Chr. Clemens Lee <clemens a.t kclee d.o.t com>
007     *
008     * Cobertura is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU General Public License as published
010     * by the Free Software Foundation; either version 2 of the License,
011     * or (at your option) any later version.
012     *
013     * Cobertura is distributed in the hope that it will be useful, but
014     * WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
016     * General Public License for more details.
017     *
018     * You should have received a copy of the GNU General Public License
019     * along with Cobertura; if not, write to the Free Software
020     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
021     * USA
022     */
023    
024    
025    /*
026     *
027     * WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING  
028     *
029     * WARNING TO COBERTURA DEVELOPERS
030     *
031     * DO NOT MODIFY THIS FILE!
032     *
033     * MODIFY THE FILES UNDER THE JAVANCSS DIRECTORY LOCATED AT THE ROOT OF THE COBERTURA PROJECT.
034     *
035     * FOLLOW THE PROCEDURE FOR MERGING THE LATEST JAVANCSS INTO COBERTURA LOCATED AT
036     * javancss/coberturaREADME.txt
037     *
038     * WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   WARNING   
039     */
040    /* Generated By:JavaCC: Do not edit this line. JavaParserTokenManager.java */
041    package net.sourceforge.cobertura.javancss.parser.java15;
042    
043    import java.io.*;
044    
045    public class JavaParser15TokenManager implements JavaParser15Constants
046    {
047      public  java.io.PrintStream debugStream = System.out;
048      public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
049    private 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    }
177    private 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    }
181    private final int jjStopAtPos(int pos, int kind)
182    {
183       jjmatchedKind = kind;
184       jjmatchedPos = pos;
185       return pos + 1;
186    }
187    private 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    }
195    private 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    }
300    private 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    }
417    private 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    }
493    private 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    }
569    private 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    }
641    private 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    }
703    private 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    }
753    private 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    }
787    private 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    }
819    private 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    }
845    private 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    }
863    private 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    }
883    private final void jjCheckNAdd(int state)
884    {
885       if (jjrounds[state] != jjround)
886       {
887          jjstateSet[jjnewStateCnt++] = state;
888          jjrounds[state] = jjround;
889       }
890    }
891    private final void jjAddStates(int start, int end)
892    {
893       do {
894          jjstateSet[jjnewStateCnt++] = jjnextStates[start];
895       } while (start++ != end);
896    }
897    private final void jjCheckNAddTwoStates(int state1, int state2)
898    {
899       jjCheckNAdd(state1);
900       jjCheckNAdd(state2);
901    }
902    private final void jjCheckNAddStates(int start, int end)
903    {
904       do {
905          jjCheckNAdd(jjnextStates[start]);
906       } while (start++ != end);
907    }
908    private final void jjCheckNAddStates(int start)
909    {
910       jjCheckNAdd(jjnextStates[start]);
911       jjCheckNAdd(jjnextStates[start + 1]);
912    }
913    static final long[] jjbitVec0 = {
914       0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
915    };
916    static final long[] jjbitVec2 = {
917       0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
918    };
919    static final long[] jjbitVec3 = {
920       0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL
921    };
922    static final long[] jjbitVec4 = {
923       0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
924    };
925    static final long[] jjbitVec5 = {
926       0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
927    };
928    static final long[] jjbitVec6 = {
929       0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
930    };
931    static final long[] jjbitVec7 = {
932       0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
933    };
934    static final long[] jjbitVec8 = {
935       0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
936    };
937    static final long[] jjbitVec9 = {
938       0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
939    };
940    static final long[] jjbitVec10 = {
941       0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
942    };
943    static final long[] jjbitVec11 = {
944       0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L
945    };
946    static final long[] jjbitVec12 = {
947       0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
948    };
949    static final long[] jjbitVec13 = {
950       0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
951    };
952    static final long[] jjbitVec14 = {
953       0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
954    };
955    static final long[] jjbitVec15 = {
956       0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
957    };
958    static final long[] jjbitVec16 = {
959       0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL
960    };
961    static final long[] jjbitVec17 = {
962       0x1L, 0x7fffffffeffL, 0xf00L, 0x0L
963    };
964    static final long[] jjbitVec18 = {
965       0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
966    };
967    static final long[] jjbitVec19 = {
968       0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
969    };
970    static final long[] jjbitVec20 = {
971       0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
972    };
973    static final long[] jjbitVec21 = {
974       0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
975    };
976    static final long[] jjbitVec22 = {
977       0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
978    };
979    static final long[] jjbitVec23 = {
980       0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L
981    };
982    static final long[] jjbitVec24 = {
983       0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
984    };
985    static final long[] jjbitVec25 = {
986       0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
987    };
988    static final long[] jjbitVec26 = {
989       0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
990    };
991    static final long[] jjbitVec27 = {
992       0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L
993    };
994    static final long[] jjbitVec28 = {
995       0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
996    };
997    static final long[] jjbitVec29 = {
998       0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL
999    };
1000    static final long[] jjbitVec30 = {
1001       0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
1002    };
1003    static final long[] jjbitVec31 = {
1004       0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
1005    };
1006    static final long[] jjbitVec32 = {
1007       0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
1008    };
1009    static final long[] jjbitVec33 = {
1010       0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
1011    };
1012    static final long[] jjbitVec34 = {
1013       0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
1014    };
1015    static final long[] jjbitVec35 = {
1016       0x3fffffffffffL, 0x0L, 0x0L, 0x0L
1017    };
1018    static final long[] jjbitVec36 = {
1019       0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1020    };
1021    static final long[] jjbitVec37 = {
1022       0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
1023    };
1024    static final long[] jjbitVec38 = {
1025       0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
1026    };
1027    static final long[] jjbitVec39 = {
1028       0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
1029    };
1030    static final long[] jjbitVec40 = {
1031       0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL
1032    };
1033    static final long[] jjbitVec41 = {
1034       0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
1035    };
1036    static final long[] jjbitVec42 = {
1037       0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
1038    };
1039    static final long[] jjbitVec43 = {
1040       0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
1041    };
1042    static final long[] jjbitVec44 = {
1043       0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
1044    };
1045    static final long[] jjbitVec45 = {
1046       0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
1047    };
1048    static final long[] jjbitVec46 = {
1049       0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL
1050    };
1051    static final long[] jjbitVec47 = {
1052       0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
1053    };
1054    static final long[] jjbitVec48 = {
1055       0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
1056    };
1057    static final long[] jjbitVec49 = {
1058       0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
1059    };
1060    static final long[] jjbitVec50 = {
1061       0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
1062    };
1063    static final long[] jjbitVec51 = {
1064       0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL
1065    };
1066    static final long[] jjbitVec52 = {
1067       0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L
1068    };
1069    static final long[] jjbitVec53 = {
1070       0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
1071    };
1072    static final long[] jjbitVec54 = {
1073       0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
1074    };
1075    static final long[] jjbitVec55 = {
1076       0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL
1077    };
1078    static final long[] jjbitVec56 = {
1079       0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
1080    };
1081    static final long[] jjbitVec57 = {
1082       0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L
1083    };
1084    static final long[] jjbitVec58 = {
1085       0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
1086    };
1087    static final long[] jjbitVec59 = {
1088       0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1089    };
1090    static final long[] jjbitVec60 = {
1091       0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
1092    };
1093    static final long[] jjbitVec61 = {
1094       0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
1095    };
1096    private 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    }
1609    private final int jjMoveStringLiteralDfa0_2()
1610    {
1611       switch(curChar)
1612       {
1613          case 42:
1614             return jjMoveStringLiteralDfa1_2(0x400L);
1615          default :
1616             return 1;
1617       }
1618    }
1619    private 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    }
1636    private final int jjMoveStringLiteralDfa0_1()
1637    {
1638       switch(curChar)
1639       {
1640          case 42:
1641             return jjMoveStringLiteralDfa1_1(0x200L);
1642          default :
1643             return 1;
1644       }
1645    }
1646    private 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    }
1663    static 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    };
1669    private 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    }
1681    private 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    }
1765    private 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    }
1849    public 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, 
1867    null, 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, };
1873    public static final String[] lexStateNames = {
1874       "DEFAULT", 
1875       "IN_FORMAL_COMMENT", 
1876       "IN_MULTI_LINE_COMMENT", 
1877    };
1878    public 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    };
1886    static final long[] jjtoToken = {
1887       0xfffffffffffff001L, 0xffffffffffff9c23L, 0x1L, 
1888    };
1889    static final long[] jjtoSkip = {
1890       0x73eL, 0x0L, 0x0L, 
1891    };
1892    static final long[] jjtoSpecial = {
1893       0x700L, 0x0L, 0x0L, 
1894    };
1895    static final long[] jjtoMore = {
1896       0x8c0L, 0x0L, 0x0L, 
1897    };
1898    protected JavaCharStream input_stream;
1899    private final int[] jjrounds = new int[70];
1900    private final int[] jjstateSet = new int[140];
1901    StringBuffer image;
1902    int jjimageLen;
1903    int lengthOfMatch;
1904    protected char curChar;
1905    public 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    }
1910    public JavaParser15TokenManager(JavaCharStream stream, int lexState){
1911       this(stream);
1912       SwitchTo(lexState);
1913    }
1914    public void ReInit(JavaCharStream stream)
1915    {
1916       jjmatchedPos = jjnewStateCnt = 0;
1917       curLexState = defaultLexState;
1918       input_stream = stream;
1919       ReInitRounds();
1920    }
1921    private final void ReInitRounds()
1922    {
1923       int i;
1924       jjround = 0x80000001;
1925       for (i = 70; i-- > 0;)
1926          jjrounds[i] = 0x80000000;
1927    }
1928    public void ReInit(JavaCharStream stream, int lexState)
1929    {
1930       ReInit(stream);
1931       SwitchTo(lexState);
1932    }
1933    public 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    
1941    protected 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    
1954    int curLexState = 0;
1955    int defaultLexState = 0;
1956    int jjnewStateCnt;
1957    int jjround;
1958    int jjmatchedPos;
1959    int jjmatchedKind;
1960    
1961    public 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    
2090    void SkipLexicalActions(Token matchedToken)
2091    {
2092       switch(jjmatchedKind)
2093       {
2094          default :
2095             break;
2096       }
2097    }
2098    void 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    }
2114    void 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    }