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