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