001    
002    package railo.runtime.sql.old;
003    
004    import java.io.IOException;
005    import java.io.PrintStream;
006    
007    // Referenced classes of package Zql:
008    //            TokenMgrError, ZqlJJParserConstants, SimpleCharStream, Token
009    
010    public final class ZqlJJParserTokenManager
011        implements ZqlJJParserConstants
012    {
013    
014        public void setDebugStream(PrintStream printstream)
015        {
016            debugStream = printstream;
017        }
018    
019        private final int jjStopStringLiteralDfa_0(int i, long l, long l1)
020        {
021            switch(i)
022            {
023            case 0: // '\0'
024                if((l1 & 0x4000000000L) != 0L)
025                    return 0;
026                if((l1 & 0x10020000000L) != 0L)
027                    return 47;
028                if((l1 & 0x80000000000L) != 0L)
029                    return 3;
030                if((l & -32L) != 0L || (l1 & 4095L) != 0L)
031                {
032                    jjmatchedKind = 82;
033                    return 48;
034                } 
035                //else{
036                    return -1;
037                //}
038    
039            case 1: // '\001'
040                if((l & 0x1a003f00004300L) != 0L)
041                    return 48;
042                if((l & 0xffe5ffc0ffffbce0L) != 0L || (l1 & 4095L) != 0L)
043                {
044                    if(jjmatchedPos != 1)
045                    {
046                        jjmatchedKind = 82;
047                        jjmatchedPos = 1;
048                    }
049                    return 48;
050                }
051                //else{
052                    return -1;
053                //}
054    
055            case 2: // '\002'
056                if((l & 0xebf5d8deefffb800L) != 0L || (l1 & 4094L) != 0L)
057                {
058                    if(jjmatchedPos != 2)
059                    {
060                        jjmatchedKind = 82;
061                        jjmatchedPos = 2;
062                    }
063                    return 48;
064                }
065                return (l & 0x14002700100006e0L) == 0L && (l1 & 1L) == 0L ? -1 : 48;
066    
067            case 3: // '\003'
068                if((l & 0x1c488d024508000L) != 0L || (l1 & 1536L) != 0L)
069                    return 48;
070                if((l & 0xea31540ecbaf3800L) != 0L || (l1 & 2558L) != 0L)
071                {
072                    jjmatchedKind = 82;
073                    jjmatchedPos = 3;
074                    return 48;
075                } 
076                //else{
077                    return -1;
078                //}
079    
080            case 4: // '\004'
081                if((l & 0xa030040048080000L) != 0L || (l1 & 2314L) != 0L)
082                    return 48;
083                if((l & 0x4a01500e83a73800L) != 0L || (l1 & 244L) != 0L)
084                {
085                    jjmatchedKind = 82;
086                    jjmatchedPos = 4;
087                    return 48;
088                }
089                //else{
090                    return -1;
091                //}
092    
093            case 5: // '\005'
094                if((l & 0x4200100c01853800L) != 0L || (l1 & 196L) != 0L)
095                {
096                    jjmatchedKind = 82;
097                    jjmatchedPos = 5;
098                    return 48;
099                }
100                return (l & 0x801400282220000L) == 0L && (l1 & 48L) == 0L ? -1 : 48;
101    
102            case 6: // '\006'
103                if((l & 4096L) != 0L)
104                {
105                    if(jjmatchedPos != 6)
106                    {
107                        jjmatchedKind = 82;
108                        jjmatchedPos = 6;
109                    }
110                    return 11;
111                }
112                if((l & 0x100400052800L) != 0L || (l1 & 192L) != 0L)
113                    return 48;
114                if((l & 0x4200000801800000L) != 0L || (l1 & 4L) != 0L)
115                {
116                    if(jjmatchedPos != 6)
117                    {
118                        jjmatchedKind = 82;
119                        jjmatchedPos = 6;
120                    }
121                    return 48;
122                } 
123                //else{
124                    return -1;
125                //}
126    
127            case 7: // '\007'
128                if((l & 0x4200000000800000L) != 0L)
129                    return 48;
130                if((l & 4096L) != 0L)
131                {
132                    jjmatchedKind = 82;
133                    jjmatchedPos = 7;
134                    return 11;
135                }
136                if((l1 & 64L) != 0L)
137                    return 11;
138                if((l & 0x801000000L) != 0L || (l1 & 4L) != 0L)
139                {
140                    jjmatchedKind = 82;
141                    jjmatchedPos = 7;
142                    return 48;
143                } 
144                //else{
145                    return -1;
146                //}
147    
148            case 8: // '\b'
149                if((l1 & 4L) != 0L)
150                {
151                    jjmatchedKind = 82;
152                    jjmatchedPos = 8;
153                    return 48;
154                }
155                if((l & 0x801000000L) != 0L)
156                    return 48;
157                if((l & 4096L) != 0L)
158                {
159                    jjmatchedKind = 82;
160                    jjmatchedPos = 8;
161                    return 11;
162                } 
163                //else{
164                    return -1;
165                //}
166    
167            case 9: // '\t'
168                if((l1 & 4L) != 0L)
169                {
170                    jjmatchedKind = 82;
171                    jjmatchedPos = 9;
172                    return 48;
173                }
174                if((l & 4096L) != 0L)
175                {
176                    jjmatchedKind = 82;
177                    jjmatchedPos = 9;
178                    return 11;
179                } 
180                //else{
181                    return -1;
182                //}
183    
184            case 10: // '\n'
185                if((l1 & 4L) != 0L)
186                    return 48;
187                if((l & 4096L) != 0L)
188                {
189                    jjmatchedKind = 82;
190                    jjmatchedPos = 10;
191                    return 11;
192                } 
193                //else{
194                    return -1;
195                //}
196    
197            case 11: // '\013'
198                if((l & 4096L) != 0L)
199                {
200                    jjmatchedKind = 82;
201                    jjmatchedPos = 11;
202                    return 11;
203                } 
204                //else{
205                    return -1;
206                //}
207    
208            case 12: // '\f'
209                if((l & 4096L) != 0L)
210                {
211                    jjmatchedKind = 82;
212                    jjmatchedPos = 12;
213                    return 11;
214                } 
215                //else{
216                    return -1;
217                //}
218            }
219            return -1;
220        }
221    
222        private final int jjStartNfa_0(int i, long l, long l1)
223        {
224            return jjMoveNfa_0(jjStopStringLiteralDfa_0(i, l, l1), i + 1);
225        }
226    
227        private final int jjStopAtPos(int i, int j)
228        {
229            jjmatchedKind = j;
230            jjmatchedPos = i;
231            return i + 1;
232        }
233    
234        private final int jjStartNfaWithStates_0(int i, int j, int k)
235        {
236            jjmatchedKind = j;
237            jjmatchedPos = i;
238            try
239            {
240                curChar = input_stream.readChar();
241            }
242            catch(IOException ioexception)
243            {
244                return i + 1;
245            }
246            return jjMoveNfa_0(k, i + 1);
247        }
248    
249        private final int jjMoveStringLiteralDfa0_0()
250        {
251            switch(curChar)
252            {
253            case 33: // '!'
254                return jjMoveStringLiteralDfa1_0(0L, 0x40000000L);
255    
256            case 35: // '#'
257                return jjStopAtPos(0, 95);
258    
259            case 40: // '('
260                return jjStopAtPos(0, 88);
261    
262            case 41: // ')'
263                return jjStopAtPos(0, 90);
264    
265            case 42: // '*'
266                jjmatchedKind = 103;
267                return jjMoveStringLiteralDfa1_0(0L, 0x100000000000L);
268    
269            case 43: // '+'
270                return jjStopAtPos(0, 101);
271    
272            case 44: // ','
273                return jjStopAtPos(0, 89);
274    
275            case 45: // '-'
276                return jjStartNfaWithStates_0(0, 102, 0);
277    
278            case 46: // '.'
279                jjmatchedKind = 93;
280                return jjMoveStringLiteralDfa1_0(0L, 0x10000000000L);
281    
282            case 47: // '/'
283                return jjStartNfaWithStates_0(0, 107, 3);
284    
285            case 59: // ';'
286                return jjStopAtPos(0, 91);
287    
288            case 60: // '<'
289                jjmatchedKind = 99;
290                return jjMoveStringLiteralDfa1_0(0L, 0x1100000000L);
291    
292            case 61: // '='
293                return jjStopAtPos(0, 92);
294    
295            case 62: // '>'
296                jjmatchedKind = 97;
297                return jjMoveStringLiteralDfa1_0(0L, 0x400000000L);
298    
299            case 63: // '?'
300                return jjStopAtPos(0, 105);
301    
302            case 65: // 'A'
303            case 97: // 'a'
304                return jjMoveStringLiteralDfa1_0(2016L, 0L);
305    
306            case 66: // 'B'
307            case 98: // 'b'
308                return jjMoveStringLiteralDfa1_0(30720L, 0L);
309    
310            case 67: // 'C'
311            case 99: // 'c'
312                return jjMoveStringLiteralDfa1_0(0xf8000L, 0L);
313    
314            case 68: // 'D'
315            case 100: // 'd'
316                return jjMoveStringLiteralDfa1_0(0xf00000L, 0L);
317    
318            case 69: // 'E'
319            case 101: // 'e'
320                return jjMoveStringLiteralDfa1_0(0x7000000L, 0L);
321    
322            case 70: // 'F'
323            case 102: // 'f'
324                return jjMoveStringLiteralDfa1_0(0x38000000L, 0L);
325    
326            case 71: // 'G'
327            case 103: // 'g'
328                return jjMoveStringLiteralDfa1_0(0x40000000L, 0L);
329    
330            case 72: // 'H'
331            case 104: // 'h'
332                return jjMoveStringLiteralDfa1_0(0x80000000L, 0L);
333    
334            case 73: // 'I'
335            case 105: // 'i'
336                return jjMoveStringLiteralDfa1_0(0x3f00000000L, 0L);
337    
338            case 76: // 'L'
339            case 108: // 'l'
340                return jjMoveStringLiteralDfa1_0(0xc000000000L, 0L);
341    
342            case 77: // 'M'
343            case 109: // 'm'
344                return jjMoveStringLiteralDfa1_0(0xf0000000000L, 0L);
345    
346            case 78: // 'N'
347            case 110: // 'n'
348                return jjMoveStringLiteralDfa1_0(0x1f00000000000L, 0L);
349    
350            case 79: // 'O'
351            case 111: // 'o'
352                return jjMoveStringLiteralDfa1_0(0x1e000000000000L, 0L);
353    
354            case 80: // 'P'
355            case 112: // 'p'
356                return jjMoveStringLiteralDfa1_0(0x20000000000000L, 0L);
357    
358            case 81: // 'Q'
359            case 113: // 'q'
360                return jjMoveStringLiteralDfa1_0(0x40000000000000L, 0L);
361    
362            case 82: // 'R'
363            case 114: // 'r'
364                return jjMoveStringLiteralDfa1_0(0x780000000000000L, 0L);
365    
366            case 83: // 'S'
367            case 115: // 's'
368                return jjMoveStringLiteralDfa1_0(0xf800000000000000L, 1L);
369    
370            case 84: // 'T'
371            case 116: // 't'
372                return jjMoveStringLiteralDfa1_0(0L, 6L);
373    
374            case 85: // 'U'
375            case 117: // 'u'
376                return jjMoveStringLiteralDfa1_0(0L, 24L);
377    
378            case 86: // 'V'
379            case 118: // 'v'
380                return jjMoveStringLiteralDfa1_0(0L, 224L);
381    
382            case 87: // 'W'
383            case 119: // 'w'
384                return jjMoveStringLiteralDfa1_0(0L, 3840L);
385    
386            case 124: // '|'
387                return jjMoveStringLiteralDfa1_0(0L, 0x40000000000L);
388    
389            case 34: // '"'
390            case 36: // '$'
391            case 37: // '%'
392            case 38: // '&'
393            case 39: // '\''
394            case 48: // '0'
395            case 49: // '1'
396            case 50: // '2'
397            case 51: // '3'
398            case 52: // '4'
399            case 53: // '5'
400            case 54: // '6'
401            case 55: // '7'
402            case 56: // '8'
403            case 57: // '9'
404            case 58: // ':'
405            case 64: // '@'
406            case 74: // 'J'
407            case 75: // 'K'
408            case 88: // 'X'
409            case 89: // 'Y'
410            case 90: // 'Z'
411            case 91: // '['
412            case 92: // '\\'
413            case 93: // ']'
414            case 94: // '^'
415            case 95: // '_'
416            case 96: // '`'
417            case 106: // 'j'
418            case 107: // 'k'
419            case 120: // 'x'
420            case 121: // 'y'
421            case 122: // 'z'
422            case 123: // '{'
423            default:
424                return jjMoveNfa_0(2, 0);
425            }
426        }
427    
428        private final int jjMoveStringLiteralDfa1_0(long l, long l1)
429        {
430            try
431            {
432                curChar = input_stream.readChar();
433            }
434            catch(IOException ioexception)
435            {
436                jjStopStringLiteralDfa_0(0, l, l1);
437                return 1;
438            }
439            switch(curChar)
440            {
441            case 43: // '+'
442            case 44: // ','
443            case 45: // '-'
444            case 46: // '.'
445            case 47: // '/'
446            case 48: // '0'
447            case 49: // '1'
448            case 50: // '2'
449            case 51: // '3'
450            case 52: // '4'
451            case 53: // '5'
452            case 54: // '6'
453            case 55: // '7'
454            case 56: // '8'
455            case 57: // '9'
456            case 58: // ':'
457            case 59: // ';'
458            case 60: // '<'
459            case 63: // '?'
460            case 64: // '@'
461            case 66: // 'B'
462            case 67: // 'C'
463            case 68: // 'D'
464            case 71: // 'G'
465            case 74: // 'J'
466            case 75: // 'K'
467            case 81: // 'Q'
468            case 87: // 'W'
469            case 90: // 'Z'
470            case 91: // '['
471            case 92: // '\\'
472            case 93: // ']'
473            case 94: // '^'
474            case 95: // '_'
475            case 96: // '`'
476            case 98: // 'b'
477            case 99: // 'c'
478            case 100: // 'd'
479            case 103: // 'g'
480            case 106: // 'j'
481            case 107: // 'k'
482            case 113: // 'q'
483            case 119: // 'w'
484            case 122: // 'z'
485            case 123: // '{'
486            default:
487                break;
488    
489            case 42: // '*'
490                if((l1 & 0x10000000000L) != 0L)
491                    return jjStopAtPos(1, 104);
492                if((l1 & 0x100000000000L) != 0L)
493                    return jjStopAtPos(1, 108);
494                break;
495    
496            case 61: // '='
497                if((l1 & 0x40000000L) != 0L)
498                    return jjStopAtPos(1, 94);
499                if((l1 & 0x400000000L) != 0L)
500                    return jjStopAtPos(1, 98);
501                if((l1 & 0x1000000000L) != 0L)
502                    return jjStopAtPos(1, 100);
503                break;
504    
505            case 62: // '>'
506                if((l1 & 0x100000000L) != 0L)
507                    return jjStopAtPos(1, 96);
508                break;
509    
510            case 65: // 'A'
511            case 97: // 'a'
512                return jjMoveStringLiteralDfa2_0(l, 0x110080100000L, l1, 226L);
513    
514            case 69: // 'E'
515            case 101: // 'e'
516                return jjMoveStringLiteralDfa2_0(l, 0x1980000000600800L, l1, 0L);
517    
518            case 70: // 'F'
519            case 102: // 'f'
520                if((l & 0x2000000000000L) != 0L)
521                    return jjStartNfaWithStates_0(1, 49, 48);
522                break;
523    
524            case 72: // 'H'
525            case 104: // 'h'
526                return jjMoveStringLiteralDfa2_0(l, 0x2000000000008000L, l1, 256L);
527    
528            case 73: // 'I'
529            case 105: // 'i'
530                return jjMoveStringLiteralDfa2_0(l, 0x64000801000L, l1, 512L);
531    
532            case 76: // 'L'
533            case 108: // 'l'
534                return jjMoveStringLiteralDfa2_0(l, 0x8000020L, l1, 0L);
535    
536            case 77: // 'M'
537            case 109: // 'm'
538                return jjMoveStringLiteralDfa2_0(l, 0x4000000000000000L, l1, 0L);
539    
540            case 78: // 'N'
541            case 110: // 'n'
542                if((l & 0x100000000L) != 0L)
543                {
544                    jjmatchedKind = 32;
545                    jjmatchedPos = 1;
546                }
547                return jjMoveStringLiteralDfa2_0(l, 0x4001e000000c0L, l1, 8L);
548    
549            case 79: // 'O'
550            case 111: // 'o'
551                return jjMoveStringLiteralDfa2_0(l, 0x6006880100f2000L, l1, 1024L);
552    
553            case 80: // 'P'
554            case 112: // 'p'
555                return jjMoveStringLiteralDfa2_0(l, 0L, l1, 16L);
556    
557            case 82: // 'R'
558            case 114: // 'r'
559                if((l & 0x8000000000000L) != 0L)
560                {
561                    jjmatchedKind = 51;
562                    jjmatchedPos = 1;
563                }
564                return jjMoveStringLiteralDfa2_0(l, 0x30000060000000L, l1, 2052L);
565    
566            case 83: // 'S'
567            case 115: // 's'
568                if((l & 256L) != 0L)
569                {
570                    jjmatchedKind = 8;
571                    jjmatchedPos = 1;
572                } else
573                if((l & 0x2000000000L) != 0L)
574                    return jjStartNfaWithStates_0(1, 37, 48);
575                return jjMoveStringLiteralDfa2_0(l, 512L, l1, 0L);
576    
577            case 84: // 'T'
578            case 116: // 't'
579                return jjMoveStringLiteralDfa2_0(l, 0x8000000000000000L, l1, 0L);
580    
581            case 85: // 'U'
582            case 117: // 'u'
583                return jjMoveStringLiteralDfa2_0(l, 0x41800000000000L, l1, 1L);
584    
585            case 86: // 'V'
586            case 118: // 'v'
587                return jjMoveStringLiteralDfa2_0(l, 1024L, l1, 0L);
588    
589            case 88: // 'X'
590            case 120: // 'x'
591                return jjMoveStringLiteralDfa2_0(l, 0x7000000L, l1, 0L);
592    
593            case 89: // 'Y'
594            case 121: // 'y'
595                if((l & 16384L) != 0L)
596                    return jjStartNfaWithStates_0(1, 14, 48);
597                break;
598    
599            case 124: // '|'
600                if((l1 & 0x40000000000L) != 0L)
601                    return jjStopAtPos(1, 106);
602                break;
603            }
604            return jjStartNfa_0(0, l, l1);
605        }
606    
607        private final int jjMoveStringLiteralDfa2_0(long l, long l1, long l2, long l3)
608        {
609            if(((l1 &= l) | (l3 &= l2)) == 0L)
610                return jjStartNfa_0(0, l, l2);
611            try
612            {
613                curChar = input_stream.readChar();
614            }
615            catch(IOException ioexception)
616            {
617                jjStopStringLiteralDfa_0(1, l1, l3);
618                return 2;
619            }
620            switch(curChar)
621            {
622            case 70: // 'F'
623            case 72: // 'H'
624            case 74: // 'J'
625            case 80: // 'P'
626            case 81: // 'Q'
627            case 90: // 'Z'
628            case 91: // '['
629            case 92: // '\\'
630            case 93: // ']'
631            case 94: // '^'
632            case 95: // '_'
633            case 96: // '`'
634            case 102: // 'f'
635            case 104: // 'h'
636            case 106: // 'j'
637            case 112: // 'p'
638            case 113: // 'q'
639            default:
640                break;
641    
642            case 65: // 'A'
643            case 97: // 'a'
644                return jjMoveStringLiteralDfa3_0(l1, 0xe180000000008000L, l3, 4L);
645    
646            case 66: // 'B'
647            case 98: // 'b'
648                return jjMoveStringLiteralDfa3_0(l1, 0L, l3, 2L);
649    
650            case 67: // 'C'
651            case 99: // 'c'
652                if((l1 & 512L) != 0L)
653                    return jjStartNfaWithStates_0(2, 9, 48);
654                //else
655                    return jjMoveStringLiteralDfa3_0(l1, 0x8001000000L, l3, 0L);
656    
657            case 68: // 'D'
658            case 100: // 'd'
659                if((l1 & 64L) != 0L)
660                    return jjStartNfaWithStates_0(2, 6, 48);
661                //else
662                    return jjMoveStringLiteralDfa3_0(l1, 0x10080000000000L, l3, 16L);
663    
664            case 69: // 'E'
665            case 101: // 'e'
666                return jjMoveStringLiteralDfa3_0(l1, 0L, l3, 256L);
667    
668            case 71: // 'G'
669            case 103: // 'g'
670                if((l1 & 1024L) != 0L)
671                    return jjStartNfaWithStates_0(2, 10, 48);
672                break;
673    
674            case 73: // 'I'
675            case 105: // 'i'
676                return jjMoveStringLiteralDfa3_0(l1, 0x60000006000000L, l3, 2056L);
677    
678            case 75: // 'K'
679            case 107: // 'k'
680                return jjMoveStringLiteralDfa3_0(l1, 0x4000000000L, l3, 0L);
681    
682            case 76: // 'L'
683            case 108: // 'l'
684                if((l1 & 32L) != 0L)
685                    return jjStartNfaWithStates_0(2, 5, 48);
686                
687                    return jjMoveStringLiteralDfa3_0(l1, 0xa04800000200000L, l3, 32L);
688    
689            case 77: // 'M'
690            case 109: // 'm'
691                if((l3 & 1L) != 0L)
692                    return jjStartNfaWithStates_0(2, 64, 48);
693                
694                    return jjMoveStringLiteralDfa3_0(l1, 0x1000000030000L, l3, 0L);
695    
696            case 78: // 'N'
697            case 110: // 'n'
698                if((l1 & 0x20000000000L) != 0L)
699                {
700                    jjmatchedKind = 41;
701                    jjmatchedPos = 2;
702                }
703                return jjMoveStringLiteralDfa3_0(l1, 0x40000041000L, l3, 0L);
704    
705            case 79: // 'O'
706            case 111: // 'o'
707                return jjMoveStringLiteralDfa3_0(l1, 0x68002000L, l3, 0L);
708    
709            case 82: // 'R'
710            case 114: // 'r'
711                if((l1 & 0x10000000L) != 0L)
712                    return jjStartNfaWithStates_0(2, 28, 48);
713                return jjMoveStringLiteralDfa3_0(l1, 0L, l3, 1216L);
714    
715            case 83: // 'S'
716            case 115: // 's'
717                return jjMoveStringLiteralDfa3_0(l1, 0x200c00000L, l3, 0L);
718    
719            case 84: // 'T'
720            case 116: // 't'
721                if((l1 & 0x200000000000L) != 0L)
722                    return jjStartNfaWithStates_0(2, 45, 48);
723                if((l1 & 0x1000000000000000L) != 0L)
724                    return jjStartNfaWithStates_0(2, 60, 48);
725                return jjMoveStringLiteralDfa3_0(l1, 0x101c00100800L, l3, 512L);
726    
727            case 85: // 'U'
728            case 117: // 'u'
729                return jjMoveStringLiteralDfa3_0(l1, 0x80000L, l3, 0L);
730    
731            case 86: // 'V'
732            case 118: // 'v'
733                return jjMoveStringLiteralDfa3_0(l1, 0x80000000L, l3, 0L);
734    
735            case 87: // 'W'
736            case 119: // 'w'
737                if((l1 & 0x400000000000000L) != 0L)
738                    return jjStartNfaWithStates_0(2, 58, 48);
739                return jjMoveStringLiteralDfa3_0(l1, 0x400000000000L, l3, 0L);
740    
741            case 88: // 'X'
742            case 120: // 'x'
743                if((l1 & 0x10000000000L) != 0L)
744                    return jjStartNfaWithStates_0(2, 40, 48);
745                break;
746    
747            case 89: // 'Y'
748            case 121: // 'y'
749                if((l1 & 128L) != 0L)
750                    return jjStartNfaWithStates_0(2, 7, 48);
751                break;
752            }
753            return jjStartNfa_0(1, l1, l3);
754        }
755    
756        private final int jjMoveStringLiteralDfa3_0(long l, long l1, long l2, long l3)
757        {
758            if(((l1 &= l) | (l3 &= l2)) == 0L)
759                return jjStartNfa_0(1, l, l2);
760            try
761            {
762                curChar = input_stream.readChar();
763            }
764            catch(IOException ioexception)
765            {
766                jjStopStringLiteralDfa_0(2, l1, l3);
767                return 3;
768            }
769            switch(curChar)
770            {
771            case 70: // 'F'
772            case 71: // 'G'
773            case 74: // 'J'
774            case 80: // 'P'
775            case 81: // 'Q'
776            case 86: // 'V'
777            case 88: // 'X'
778            case 90: // 'Z'
779            case 91: // '['
780            case 92: // '\\'
781            case 93: // ']'
782            case 94: // '^'
783            case 95: // '_'
784            case 96: // '`'
785            case 102: // 'f'
786            case 103: // 'g'
787            case 106: // 'j'
788            case 112: // 'p'
789            case 113: // 'q'
790            case 118: // 'v'
791            case 120: // 'x'
792            default:
793                break;
794    
795            case 65: // 'A'
796            case 97: // 'a'
797                return jjMoveStringLiteralDfa4_0(l1, 0x400008001000L, l3, 16L);
798    
799            case 66: // 'B'
800            case 98: // 'b'
801                return jjMoveStringLiteralDfa4_0(l1, 0x1000000000000L, l3, 0L);
802    
803            case 67: // 'C'
804            case 99: // 'c'
805                if((l1 & 0x400000L) != 0L)
806                    return jjStartNfaWithStates_0(3, 22, 48);
807                return jjMoveStringLiteralDfa4_0(l1, 0L, l3, 192L);
808    
809            case 68: // 'D'
810            case 100: // 'd'
811                if((l1 & 0x80000000000000L) != 0L)
812                    return jjStartNfaWithStates_0(3, 55, 48);
813                break;
814    
815            case 69: // 'E'
816            case 101: // 'e'
817                if((l1 & 0x100000L) != 0L)
818                    return jjStartNfaWithStates_0(3, 20, 48);
819                if((l1 & 0x4000000000L) != 0L)
820                    return jjStartNfaWithStates_0(3, 38, 48);
821                if((l1 & 0x80000000000L) != 0L)
822                    return jjStartNfaWithStates_0(3, 43, 48);
823                return jjMoveStringLiteralDfa4_0(l1, 0x810000e00200000L, l3, 0L);
824    
825            case 72: // 'H'
826            case 104: // 'h'
827                if((l3 & 512L) != 0L)
828                    return jjStartNfaWithStates_0(3, 73, 48);
829                break;
830    
831            case 73: // 'I'
832            case 105: // 'i'
833                return jjMoveStringLiteralDfa4_0(l1, 0x80000000L, l3, 0L);
834    
835            case 75: // 'K'
836            case 107: // 'k'
837                if((l1 & 0x8000000000L) != 0L)
838                    return jjStartNfaWithStates_0(3, 39, 48);
839                if((l3 & 1024L) != 0L)
840                    return jjStartNfaWithStates_0(3, 74, 48);
841                break;
842    
843            case 76: // 'L'
844            case 108: // 'l'
845                if((l1 & 0x800000000000L) != 0L)
846                    return jjStartNfaWithStates_0(3, 47, 48);
847                if((l1 & 0x100000000000000L) != 0L)
848                    return jjStartNfaWithStates_0(3, 56, 48);
849                return jjMoveStringLiteralDfa4_0(l1, 0x4200000001002000L, l3, 2L);
850    
851            case 77: // 'M'
852            case 109: // 'm'
853                if((l1 & 0x20000000L) != 0L)
854                    return jjStartNfaWithStates_0(3, 29, 48);
855                return jjMoveStringLiteralDfa4_0(l1, 0x30000L, l3, 0L);
856    
857            case 78: // 'N'
858            case 110: // 'n'
859                return jjMoveStringLiteralDfa4_0(l1, 0xc0000L, l3, 4L);
860    
861            case 79: // 'O'
862            case 111: // 'o'
863                if((l1 & 0x1000000000L) != 0L)
864                    return jjStartNfaWithStates_0(3, 36, 48);
865                return jjMoveStringLiteralDfa4_0(l1, 0x20000000000000L, l3, 8L);
866    
867            case 82: // 'R'
868            case 114: // 'r'
869                if((l1 & 32768L) != 0L)
870                    return jjStartNfaWithStates_0(3, 15, 48);
871                return jjMoveStringLiteralDfa4_0(l1, 0xa000000000000000L, l3, 256L);
872    
873            case 83: // 'S'
874            case 115: // 's'
875                return jjMoveStringLiteralDfa4_0(l1, 0x2000000L, l3, 0L);
876    
877            case 84: // 'T'
878            case 116: // 't'
879                if((l1 & 0x4000000L) != 0L)
880                    return jjStartNfaWithStates_0(3, 26, 48);
881                if((l1 & 0x40000000000000L) != 0L)
882                    return jjStartNfaWithStates_0(3, 54, 48);
883                return jjMoveStringLiteralDfa4_0(l1, 0x800000L, l3, 2048L);
884    
885            case 85: // 'U'
886            case 117: // 'u'
887                return jjMoveStringLiteralDfa4_0(l1, 0x140040000000L, l3, 32L);
888    
889            case 87: // 'W'
890            case 119: // 'w'
891                return jjMoveStringLiteralDfa4_0(l1, 2048L, l3, 0L);
892    
893            case 89: // 'Y'
894            case 121: // 'y'
895                if((l1 & 0x4000000000000L) != 0L)
896                    return jjStartNfaWithStates_0(3, 50, 48);
897                break;
898            }
899            return jjStartNfa_0(2, l1, l3);
900        }
901    
902        private final int jjMoveStringLiteralDfa4_0(long l, long l1, long l2, long l3)
903        {
904            if(((l1 &= l) | (l3 &= l2)) == 0L)
905                return jjStartNfa_0(2, l, l2);
906            try
907            {
908                curChar = input_stream.readChar();
909            }
910            catch(IOException ioexception)
911            {
912                jjStopStringLiteralDfa_0(3, l1, l3);
913                return 4;
914            }
915            switch(curChar)
916            {
917            case 68: // 'D'
918            case 70: // 'F'
919            case 74: // 'J'
920            case 75: // 'K'
921            case 77: // 'M'
922            case 79: // 'O'
923            case 81: // 'Q'
924            case 86: // 'V'
925            case 87: // 'W'
926            case 88: // 'X'
927            case 89: // 'Y'
928            case 90: // 'Z'
929            case 91: // '['
930            case 92: // '\\'
931            case 93: // ']'
932            case 94: // '^'
933            case 95: // '_'
934            case 96: // '`'
935            case 97: // 'a'
936            case 100: // 'd'
937            case 102: // 'f'
938            case 106: // 'j'
939            case 107: // 'k'
940            case 109: // 'm'
941            case 111: // 'o'
942            case 113: // 'q'
943            default:
944                break;
945    
946            case 66: // 'B'
947            case 98: // 'b'
948                return jjMoveStringLiteralDfa5_0(l1, 0x200000000000000L, l3, 0L);
949    
950            case 67: // 'C'
951            case 99: // 'c'
952                return jjMoveStringLiteralDfa5_0(l1, 0x800000000000000L, l3, 0L);
953    
954            case 69: // 'E'
955            case 101: // 'e'
956                if((l1 & 0x2000000000000000L) != 0L)
957                    return jjStartNfaWithStates_0(4, 61, 48);
958                if((l3 & 2L) != 0L)
959                    return jjStartNfaWithStates_0(4, 65, 48);
960                if((l3 & 256L) != 0L)
961                    return jjStartNfaWithStates_0(4, 72, 48);
962                if((l3 & 2048L) != 0L)
963                    return jjStartNfaWithStates_0(4, 75, 48);
964                return jjMoveStringLiteralDfa5_0(l1, 0x1000000052800L, l3, 32L);
965    
966            case 71: // 'G'
967            case 103: // 'g'
968                return jjMoveStringLiteralDfa5_0(l1, 0x400000000L, l3, 0L);
969    
970            case 72: // 'H'
971            case 104: // 'h'
972                return jjMoveStringLiteralDfa5_0(l1, 0L, l3, 192L);
973    
974            case 73: // 'I'
975            case 105: // 'i'
976                return jjMoveStringLiteralDfa5_0(l1, 0x400000820000L, l3, 0L);
977    
978            case 76: // 'L'
979            case 108: // 'l'
980                return jjMoveStringLiteralDfa5_0(l1, 0x4000000000000000L, l3, 0L);
981    
982            case 78: // 'N'
983            case 110: // 'n'
984                if((l3 & 8L) != 0L)
985                    return jjStartNfaWithStates_0(4, 67, 48);
986                return jjMoveStringLiteralDfa5_0(l1, 0x80000000L, l3, 0L);
987    
988            case 80: // 'P'
989            case 112: // 'p'
990                if((l1 & 0x40000000L) != 0L)
991                    return jjStartNfaWithStates_0(4, 30, 48);
992                break;
993    
994            case 82: // 'R'
995            case 114: // 'r'
996                if((l1 & 0x10000000000000L) != 0L)
997                    return jjStartNfaWithStates_0(4, 52, 48);
998                if((l1 & 0x20000000000000L) != 0L)
999                    return jjStartNfaWithStates_0(4, 53, 48);
1000                return jjMoveStringLiteralDfa5_0(l1, 0x100a00001000L, l3, 0L);
1001    
1002            case 83: // 'S'
1003            case 115: // 's'
1004                if((l1 & 0x40000000000L) != 0L)
1005                    return jjStartNfaWithStates_0(4, 42, 48);
1006                return jjMoveStringLiteralDfa5_0(l1, 0L, l3, 4L);
1007    
1008            case 84: // 'T'
1009            case 116: // 't'
1010                if((l1 & 0x80000L) != 0L)
1011                    return jjStartNfaWithStates_0(4, 19, 48);
1012                if((l1 & 0x8000000L) != 0L)
1013                    return jjStartNfaWithStates_0(4, 27, 48);
1014                if((l1 & 0x8000000000000000L) != 0L)
1015                    return jjStartNfaWithStates_0(4, 63, 48);
1016                return jjMoveStringLiteralDfa5_0(l1, 0x2200000L, l3, 16L);
1017    
1018            case 85: // 'U'
1019            case 117: // 'u'
1020                return jjMoveStringLiteralDfa5_0(l1, 0x1000000L, l3, 0L);
1021            }
1022            return jjStartNfa_0(3, l1, l3);
1023        }
1024    
1025        private final int jjMoveStringLiteralDfa5_0(long l, long l1, long l2, long l3)
1026        {
1027            if(((l1 &= l) | (l3 &= l2)) == 0L)
1028                return jjStartNfa_0(3, l, l2);
1029            try
1030            {
1031                curChar = input_stream.readChar();
1032            }
1033            catch(IOException ioexception)
1034            {
1035                jjStopStringLiteralDfa_0(4, l1, l3);
1036                return 5;
1037            }
1038            switch(curChar)
1039            {
1040            case 66: // 'B'
1041            case 68: // 'D'
1042            case 70: // 'F'
1043            case 72: // 'H'
1044            case 74: // 'J'
1045            case 75: // 'K'
1046            case 76: // 'L'
1047            case 77: // 'M'
1048            case 79: // 'O'
1049            case 80: // 'P'
1050            case 81: // 'Q'
1051            case 85: // 'U'
1052            case 86: // 'V'
1053            case 87: // 'W'
1054            case 88: // 'X'
1055            case 90: // 'Z'
1056            case 91: // '['
1057            case 92: // '\\'
1058            case 93: // ']'
1059            case 94: // '^'
1060            case 95: // '_'
1061            case 96: // '`'
1062            case 98: // 'b'
1063            case 100: // 'd'
1064            case 102: // 'f'
1065            case 104: // 'h'
1066            case 106: // 'j'
1067            case 107: // 'k'
1068            case 108: // 'l'
1069            case 109: // 'm'
1070            case 111: // 'o'
1071            case 112: // 'p'
1072            case 113: // 'q'
1073            case 117: // 'u'
1074            case 118: // 'v'
1075            case 119: // 'w'
1076            case 120: // 'x'
1077            default:
1078                break;
1079    
1080            case 65: // 'A'
1081            case 97: // 'a'
1082                return jjMoveStringLiteralDfa6_0(l1, 0x200100000002000L, l3, 196L);
1083    
1084            case 67: // 'C'
1085            case 99: // 'c'
1086                return jjMoveStringLiteralDfa6_0(l1, 0x40000L, l3, 0L);
1087    
1088            case 69: // 'E'
1089            case 101: // 'e'
1090                if((l1 & 0x200000L) != 0L)
1091                    return jjStartNfaWithStates_0(5, 21, 48);
1092                if((l3 & 16L) != 0L)
1093                    return jjStartNfaWithStates_0(5, 68, 48);
1094                return jjMoveStringLiteralDfa6_0(l1, 0x400000800L, l3, 0L);
1095    
1096            case 71: // 'G'
1097            case 103: // 'g'
1098                if((l1 & 0x80000000L) != 0L)
1099                    return jjStartNfaWithStates_0(5, 31, 48);
1100                break;
1101    
1102            case 73: // 'I'
1103            case 105: // 'i'
1104                return jjMoveStringLiteralDfa6_0(l1, 0x4000000000000000L, l3, 0L);
1105    
1106            case 78: // 'N'
1107            case 110: // 'n'
1108                return jjMoveStringLiteralDfa6_0(l1, 0x810000L, l3, 0L);
1109    
1110            case 82: // 'R'
1111            case 114: // 'r'
1112                if((l1 & 0x1000000000000L) != 0L)
1113                    return jjStartNfaWithStates_0(5, 48, 48);
1114                break;
1115    
1116            case 83: // 'S'
1117            case 115: // 's'
1118                if((l1 & 0x2000000L) != 0L)
1119                    return jjStartNfaWithStates_0(5, 25, 48);
1120                if((l3 & 32L) != 0L)
1121                    return jjStartNfaWithStates_0(5, 69, 48);
1122                return jjMoveStringLiteralDfa6_0(l1, 0x801000000L, l3, 0L);
1123    
1124            case 84: // 'T'
1125            case 116: // 't'
1126                if((l1 & 0x20000L) != 0L)
1127                    return jjStartNfaWithStates_0(5, 17, 48);
1128                if((l1 & 0x200000000L) != 0L)
1129                    return jjStartNfaWithStates_0(5, 33, 48);
1130                if((l1 & 0x400000000000L) != 0L)
1131                    return jjStartNfaWithStates_0(5, 46, 48);
1132                if((l1 & 0x800000000000000L) != 0L)
1133                    return jjStartNfaWithStates_0(5, 59, 48);
1134                break;
1135    
1136            case 89: // 'Y'
1137            case 121: // 'y'
1138                return jjMoveStringLiteralDfa6_0(l1, 4096L, l3, 0L);
1139            }
1140            return jjStartNfa_0(4, l1, l3);
1141        }
1142    
1143        private final int jjMoveStringLiteralDfa6_0(long l, long l1, long l2, long l3)
1144        {
1145            if(((l1 &= l) | (l3 &= l2)) == 0L)
1146                return jjStartNfa_0(4, l, l2);
1147            try
1148            {
1149                curChar = input_stream.readChar();
1150            }
1151            catch(IOException ioexception)
1152            {
1153                jjStopStringLiteralDfa_0(5, l1, l3);
1154                return 6;
1155            }
1156            switch(curChar)
1157            {
1158            case 68: // 'D'
1159            case 70: // 'F'
1160            case 71: // 'G'
1161            case 72: // 'H'
1162            case 74: // 'J'
1163            case 75: // 'K'
1164            case 77: // 'M'
1165            case 79: // 'O'
1166            case 80: // 'P'
1167            case 81: // 'Q'
1168            case 83: // 'S'
1169            case 85: // 'U'
1170            case 86: // 'V'
1171            case 87: // 'W'
1172            case 88: // 'X'
1173            case 89: // 'Y'
1174            case 90: // 'Z'
1175            case 91: // '['
1176            case 92: // '\\'
1177            case 93: // ']'
1178            case 94: // '^'
1179            case 96: // '`'
1180            case 97: // 'a'
1181            case 98: // 'b'
1182            case 100: // 'd'
1183            case 102: // 'f'
1184            case 103: // 'g'
1185            case 104: // 'h'
1186            case 106: // 'j'
1187            case 107: // 'k'
1188            case 109: // 'm'
1189            case 111: // 'o'
1190            case 112: // 'p'
1191            case 113: // 'q'
1192            case 115: // 's'
1193            default:
1194                break;
1195    
1196            case 95: // '_'
1197                return jjMoveStringLiteralDfa7_0(l1, 4096L, l3, 0L);
1198    
1199            case 67: // 'C'
1200            case 99: // 'c'
1201                return jjMoveStringLiteralDfa7_0(l1, 0x200000000800000L, l3, 4L);
1202    
1203            case 69: // 'E'
1204            case 101: // 'e'
1205                return jjMoveStringLiteralDfa7_0(l1, 0x800000000L, l3, 0L);
1206    
1207            case 73: // 'I'
1208            case 105: // 'i'
1209                return jjMoveStringLiteralDfa7_0(l1, 0x1000000L, l3, 0L);
1210    
1211            case 76: // 'L'
1212            case 108: // 'l'
1213                if((l1 & 0x100000000000L) != 0L)
1214                    return jjStartNfaWithStates_0(6, 44, 48);
1215                break;
1216    
1217            case 78: // 'N'
1218            case 110: // 'n'
1219                if((l1 & 2048L) != 0L)
1220                    return jjStartNfaWithStates_0(6, 11, 48);
1221                if((l1 & 8192L) != 0L)
1222                    return jjStartNfaWithStates_0(6, 13, 48);
1223                return jjMoveStringLiteralDfa7_0(l1, 0x4000000000000000L, l3, 0L);
1224    
1225            case 82: // 'R'
1226            case 114: // 'r'
1227                if((l1 & 0x400000000L) != 0L)
1228                    return jjStartNfaWithStates_0(6, 34, 48);
1229                if((l3 & 128L) != 0L)
1230                {
1231                    jjmatchedKind = 71;
1232                    jjmatchedPos = 6;
1233                }
1234                return jjMoveStringLiteralDfa7_0(l1, 0L, l3, 64L);
1235    
1236            case 84: // 'T'
1237            case 116: // 't'
1238                if((l1 & 0x10000L) != 0L)
1239                    return jjStartNfaWithStates_0(6, 16, 48);
1240                if((l1 & 0x40000L) != 0L)
1241                    return jjStartNfaWithStates_0(6, 18, 48);
1242                break;
1243            }
1244            return jjStartNfa_0(5, l1, l3);
1245        }
1246    
1247        private final int jjMoveStringLiteralDfa7_0(long l, long l1, long l2, long l3)
1248        {
1249            if(((l1 &= l) | (l3 &= l2)) == 0L)
1250                return jjStartNfa_0(5, l, l2);
1251            try
1252            {
1253                curChar = input_stream.readChar();
1254            }
1255            catch(IOException ioexception)
1256            {
1257                jjStopStringLiteralDfa_0(6, l1, l3);
1258                return 7;
1259            }
1260            switch(curChar)
1261            {
1262            default:
1263                break;
1264    
1265            case 50: // '2'
1266                if((l3 & 64L) != 0L)
1267                    return jjStartNfaWithStates_0(7, 70, 11);
1268                break;
1269    
1270            case 67: // 'C'
1271            case 99: // 'c'
1272                return jjMoveStringLiteralDfa8_0(l1, 0x800000000L, l3, 0L);
1273    
1274            case 73: // 'I'
1275            case 105: // 'i'
1276                return jjMoveStringLiteralDfa8_0(l1, 4096L, l3, 0L);
1277    
1278            case 75: // 'K'
1279            case 107: // 'k'
1280                if((l1 & 0x200000000000000L) != 0L)
1281                    return jjStartNfaWithStates_0(7, 57, 48);
1282                break;
1283    
1284            case 84: // 'T'
1285            case 116: // 't'
1286                if((l1 & 0x800000L) != 0L)
1287                    return jjStartNfaWithStates_0(7, 23, 48);
1288                if((l1 & 0x4000000000000000L) != 0L)
1289                    return jjStartNfaWithStates_0(7, 62, 48);
1290                return jjMoveStringLiteralDfa8_0(l1, 0L, l3, 4L);
1291    
1292            case 86: // 'V'
1293            case 118: // 'v'
1294                return jjMoveStringLiteralDfa8_0(l1, 0x1000000L, l3, 0L);
1295            }
1296            return jjStartNfa_0(6, l1, l3);
1297        }
1298    
1299        private final int jjMoveStringLiteralDfa8_0(long l, long l1, long l2, long l3)
1300        {
1301            if(((l1 &= l) | (l3 &= l2)) == 0L)
1302                return jjStartNfa_0(6, l, l2);
1303            try
1304            {
1305                curChar = input_stream.readChar();
1306            }
1307            catch(IOException ioexception)
1308            {
1309                jjStopStringLiteralDfa_0(7, l1, l3);
1310                return 8;
1311            }
1312            switch(curChar)
1313            {
1314            default:
1315                break;
1316    
1317            case 69: // 'E'
1318            case 101: // 'e'
1319                if((l1 & 0x1000000L) != 0L)
1320                    return jjStartNfaWithStates_0(8, 24, 48);
1321                break;
1322    
1323            case 73: // 'I'
1324            case 105: // 'i'
1325                return jjMoveStringLiteralDfa9_0(l1, 0L, l3, 4L);
1326    
1327            case 78: // 'N'
1328            case 110: // 'n'
1329                return jjMoveStringLiteralDfa9_0(l1, 4096L, l3, 0L);
1330    
1331            case 84: // 'T'
1332            case 116: // 't'
1333                if((l1 & 0x800000000L) != 0L)
1334                    return jjStartNfaWithStates_0(8, 35, 48);
1335                break;
1336            }
1337            return jjStartNfa_0(7, l1, l3);
1338        }
1339    
1340        private final int jjMoveStringLiteralDfa9_0(long l, long l1, long l2, long l3)
1341        {
1342            if(((l1 &= l) | (l3 &= l2)) == 0L)
1343                return jjStartNfa_0(7, l, l2);
1344            try
1345            {
1346                curChar = input_stream.readChar();
1347            }
1348            catch(IOException ioexception)
1349            {
1350                jjStopStringLiteralDfa_0(8, l1, l3);
1351                return 9;
1352            }
1353            switch(curChar)
1354            {
1355            case 79: // 'O'
1356            case 111: // 'o'
1357                return jjMoveStringLiteralDfa10_0(l1, 0L, l3, 4L);
1358    
1359            case 84: // 'T'
1360            case 116: // 't'
1361                return jjMoveStringLiteralDfa10_0(l1, 4096L, l3, 0L);
1362            }
1363            return jjStartNfa_0(8, l1, l3);
1364        }
1365    
1366        private final int jjMoveStringLiteralDfa10_0(long l, long l1, long l2, long l3)
1367        {
1368            if(((l1 &= l) | (l3 &= l2)) == 0L)
1369                return jjStartNfa_0(8, l, l2);
1370            try
1371            {
1372                curChar = input_stream.readChar();
1373            }
1374            catch(IOException ioexception)
1375            {
1376                jjStopStringLiteralDfa_0(9, l1, l3);
1377                return 10;
1378            }
1379            switch(curChar)
1380            {
1381            case 69: // 'E'
1382            case 101: // 'e'
1383                return jjMoveStringLiteralDfa11_0(l1, 4096L, l3, 0L);
1384    
1385            case 78: // 'N'
1386            case 110: // 'n'
1387                if((l3 & 4L) != 0L)
1388                    return jjStartNfaWithStates_0(10, 66, 48);
1389                break;
1390            }
1391            return jjStartNfa_0(9, l1, l3);
1392        }
1393    
1394        private final int jjMoveStringLiteralDfa11_0(long l, long l1, long l2, long l3)
1395        {
1396            if(((l1 &= l) | (l3 &= l2)) == 0L)
1397                return jjStartNfa_0(9, l, l2);
1398            try
1399            {
1400                curChar = input_stream.readChar();
1401            }
1402            catch(IOException ioexception)
1403            {
1404                jjStopStringLiteralDfa_0(10, l1, 0L);
1405                return 11;
1406            }
1407            switch(curChar)
1408            {
1409            case 71: // 'G'
1410            case 103: // 'g'
1411                return jjMoveStringLiteralDfa12_0(l1, 4096L);
1412            }
1413            return jjStartNfa_0(10, l1, 0L);
1414        }
1415    
1416        private final int jjMoveStringLiteralDfa12_0(long l, long l1)
1417        {
1418            if((l1 &= l) == 0L)
1419                return jjStartNfa_0(10, l, 0L);
1420            try
1421            {
1422                curChar = input_stream.readChar();
1423            }
1424            catch(IOException ioexception)
1425            {
1426                jjStopStringLiteralDfa_0(11, l1, 0L);
1427                return 12;
1428            }
1429            switch(curChar)
1430            {
1431            case 69: // 'E'
1432            case 101: // 'e'
1433                return jjMoveStringLiteralDfa13_0(l1, 4096L);
1434            }
1435            return jjStartNfa_0(11, l1, 0L);
1436        }
1437    
1438        private final int jjMoveStringLiteralDfa13_0(long l, long l1)
1439        {
1440            if((l1 &= l) == 0L)
1441                return jjStartNfa_0(11, l, 0L);
1442            try
1443            {
1444                curChar = input_stream.readChar();
1445            }
1446            catch(IOException ioexception)
1447            {
1448                jjStopStringLiteralDfa_0(12, l1, 0L);
1449                return 13;
1450            }
1451            switch(curChar)
1452            {
1453            case 82: // 'R'
1454            case 114: // 'r'
1455                if((l1 & 4096L) != 0L)
1456                    return jjStartNfaWithStates_0(13, 12, 11);
1457                break;
1458            }
1459            return jjStartNfa_0(12, l1, 0L);
1460        }
1461    
1462        private final void jjCheckNAdd(int i)
1463        {
1464            if(jjrounds[i] != jjround)
1465            {
1466                jjstateSet[jjnewStateCnt++] = i;
1467                jjrounds[i] = jjround;
1468            }
1469        }
1470    
1471        private final void jjAddStates(int i, int j)
1472        {
1473            do
1474                jjstateSet[jjnewStateCnt++] = jjnextStates[i];
1475            while(i++ != j);
1476        }
1477    
1478        private final void jjCheckNAddTwoStates(int i, int j)
1479        {
1480            jjCheckNAdd(i);
1481            jjCheckNAdd(j);
1482        }
1483    
1484        private final void jjCheckNAddStates(int i, int j)
1485        {
1486            do
1487                jjCheckNAdd(jjnextStates[i]);
1488            while(i++ != j);
1489        }
1490    
1491        private final void jjCheckNAddStates(int i)
1492        {
1493            jjCheckNAdd(jjnextStates[i]);
1494            jjCheckNAdd(jjnextStates[i + 1]);
1495        }
1496    
1497        private final int jjMoveNfa_0(int i, int j)
1498        {
1499            int k = 0;
1500            jjnewStateCnt = 47;
1501            int l = 1;
1502            jjstateSet[0] = i;
1503            int i1 = 0x7fffffff;
1504            do
1505            {
1506                if(++jjround == 0x7fffffff)
1507                    ReInitRounds();
1508                if(curChar < '@')
1509                {
1510                    long l1 = 1L << curChar;
1511                    do
1512                        switch(jjstateSet[--l])
1513                        {
1514                        case 2: // '\002'
1515                            if((0x3ff000000000000L & l1) != 0L)
1516                            {
1517                                if(i1 > 76)
1518                                    i1 = 76;
1519                                jjCheckNAddStates(0, 6);
1520                            } else
1521                            if(curChar == '.')
1522                                jjCheckNAddTwoStates(27, 37);
1523                            else
1524                            if(curChar == '"')
1525                                jjCheckNAddTwoStates(24, 25);
1526                            else
1527                            if(curChar == '\'')
1528                                jjCheckNAddTwoStates(19, 20);
1529                            else
1530                            if(curChar == ':')
1531                                jjstateSet[jjnewStateCnt++] = 13;
1532                            else
1533                            if(curChar == '/')
1534                                jjstateSet[jjnewStateCnt++] = 3;
1535                            else
1536                            if(curChar == '-')
1537                                jjstateSet[jjnewStateCnt++] = 0;
1538                            break;
1539    
1540                        case 11: // '\013'
1541                        case 48: // '0'
1542                            if((0x3ff001000000000L & l1) != 0L)
1543                            {
1544                                if(i1 > 82)
1545                                    i1 = 82;
1546                                jjCheckNAdd(11);
1547                            }
1548                            break;
1549    
1550                        case 47: // '/'
1551                            if((0x3ff000000000000L & l1) != 0L)
1552                            {
1553                                if(i1 > 76)
1554                                    i1 = 76;
1555                                jjCheckNAdd(37);
1556                            }
1557                            if((0x3ff000000000000L & l1) != 0L)
1558                            {
1559                                if(i1 > 76)
1560                                    i1 = 76;
1561                                jjCheckNAddTwoStates(27, 28);
1562                            }
1563                            break;
1564    
1565                        case 0: // '\0'
1566                            if(curChar == '-')
1567                            {
1568                                if(i1 > 80)
1569                                    i1 = 80;
1570                                jjCheckNAdd(1);
1571                            }
1572                            break;
1573    
1574                        case 1: // '\001'
1575                            if((-9217L & l1) != 0L)
1576                            {
1577                                if(i1 > 80)
1578                                    i1 = 80;
1579                                jjCheckNAdd(1);
1580                            }
1581                            break;
1582    
1583                        case 3: // '\003'
1584                            if(curChar == '*')
1585                                jjCheckNAddTwoStates(4, 5);
1586                            break;
1587    
1588                        case 4: // '\004'
1589                            if((0xfffffbffffffffffL & l1) != 0L)
1590                                jjCheckNAddTwoStates(4, 5);
1591                            break;
1592    
1593                        case 5: // '\005'
1594                            if(curChar == '*')
1595                                jjCheckNAddStates(7, 9);
1596                            break;
1597    
1598                        case 6: // '\006'
1599                            if((0xffff7bffffffffffL & l1) != 0L)
1600                                jjCheckNAddTwoStates(7, 5);
1601                            break;
1602    
1603                        case 7: // '\007'
1604                            if((0xfffffbffffffffffL & l1) != 0L)
1605                                jjCheckNAddTwoStates(7, 5);
1606                            break;
1607    
1608                        case 8: // '\b'
1609                            if(curChar == '/' && i1 > 81)
1610                                i1 = 81;
1611                            break;
1612    
1613                        case 9: // '\t'
1614                            if(curChar == '/')
1615                                jjstateSet[jjnewStateCnt++] = 3;
1616                            break;
1617    
1618                        case 12: // '\f'
1619                            if(curChar == ':')
1620                                jjstateSet[jjnewStateCnt++] = 13;
1621                            break;
1622    
1623                        case 14: // '\016'
1624                            if((0x3ff001000000000L & l1) != 0L)
1625                            {
1626                                if(i1 > 85)
1627                                    i1 = 85;
1628                                jjAddStates(10, 11);
1629                            }
1630                            break;
1631    
1632                        case 15: // '\017'
1633                            if(curChar == '.')
1634                                jjstateSet[jjnewStateCnt++] = 16;
1635                            break;
1636    
1637                        case 17: // '\021'
1638                            if((0x3ff001000000000L & l1) != 0L)
1639                            {
1640                                if(i1 > 85)
1641                                    i1 = 85;
1642                                jjstateSet[jjnewStateCnt++] = 17;
1643                            }
1644                            break;
1645    
1646                        case 18: // '\022'
1647                            if(curChar == '\'')
1648                                jjCheckNAddTwoStates(19, 20);
1649                            break;
1650    
1651                        case 19: // '\023'
1652                            if((0xffffff7fffffffffL & l1) != 0L)
1653                                jjCheckNAddTwoStates(19, 20);
1654                            break;
1655    
1656                        case 20: // '\024'
1657                            if(curChar == '\'')
1658                            {
1659                                if(i1 > 86)
1660                                    i1 = 86;
1661                                jjstateSet[jjnewStateCnt++] = 21;
1662                            }
1663                            break;
1664    
1665                        case 21: // '\025'
1666                            if(curChar == '\'')
1667                                jjCheckNAddTwoStates(22, 20);
1668                            break;
1669    
1670                        case 22: // '\026'
1671                            if((0xffffff7fffffffffL & l1) != 0L)
1672                                jjCheckNAddTwoStates(22, 20);
1673                            break;
1674    
1675                        case 23: // '\027'
1676                            if(curChar == '"')
1677                                jjCheckNAddTwoStates(24, 25);
1678                            break;
1679    
1680                        case 24: // '\030'
1681                            if((0xfffffffbffffdbffL & l1) != 0L)
1682                                jjCheckNAddTwoStates(24, 25);
1683                            break;
1684    
1685                        case 25: // '\031'
1686                            if(curChar == '"' && i1 > 87)
1687                                i1 = 87;
1688                            break;
1689    
1690                        case 26: // '\032'
1691                            if(curChar == '.')
1692                                jjCheckNAddTwoStates(27, 37);
1693                            break;
1694    
1695                        case 27: // '\033'
1696                            if((0x3ff000000000000L & l1) != 0L)
1697                            {
1698                                if(i1 > 76)
1699                                    i1 = 76;
1700                                jjCheckNAddTwoStates(27, 28);
1701                            }
1702                            break;
1703    
1704                        case 29: // '\035'
1705                            if((0x280000000000L & l1) != 0L)
1706                                jjAddStates(12, 13);
1707                            break;
1708    
1709                        case 30: // '\036'
1710                            if(curChar == '.')
1711                                jjCheckNAdd(31);
1712                            break;
1713    
1714                        case 31: // '\037'
1715                            if((0x3ff000000000000L & l1) != 0L)
1716                            {
1717                                if(i1 > 76)
1718                                    i1 = 76;
1719                                jjCheckNAdd(31);
1720                            }
1721                            break;
1722    
1723                        case 32: // ' '
1724                            if((0x3ff000000000000L & l1) != 0L)
1725                            {
1726                                if(i1 > 76)
1727                                    i1 = 76;
1728                                jjCheckNAddStates(14, 16);
1729                            }
1730                            break;
1731    
1732                        case 33: // '!'
1733                            if((0x3ff000000000000L & l1) != 0L)
1734                            {
1735                                if(i1 > 76)
1736                                    i1 = 76;
1737                                jjCheckNAdd(33);
1738                            }
1739                            break;
1740    
1741                        case 34: // '"'
1742                            if((0x3ff000000000000L & l1) != 0L)
1743                            {
1744                                if(i1 > 76)
1745                                    i1 = 76;
1746                                jjCheckNAddTwoStates(34, 35);
1747                            }
1748                            break;
1749    
1750                        case 35: // '#'
1751                            if(curChar == '.')
1752                                jjCheckNAdd(36);
1753                            break;
1754    
1755                        case 36: // '$'
1756                            if((0x3ff000000000000L & l1) != 0L)
1757                            {
1758                                if(i1 > 76)
1759                                    i1 = 76;
1760                                jjCheckNAdd(36);
1761                            }
1762                            break;
1763    
1764                        case 37: // '%'
1765                            if((0x3ff000000000000L & l1) != 0L)
1766                            {
1767                                if(i1 > 76)
1768                                    i1 = 76;
1769                                jjCheckNAdd(37);
1770                            }
1771                            break;
1772    
1773                        case 38: // '&'
1774                            if((0x3ff000000000000L & l1) != 0L)
1775                            {
1776                                if(i1 > 76)
1777                                    i1 = 76;
1778                                jjCheckNAddStates(0, 6);
1779                            }
1780                            break;
1781    
1782                        case 39: // '\''
1783                            if((0x3ff000000000000L & l1) != 0L)
1784                            {
1785                                if(i1 > 76)
1786                                    i1 = 76;
1787                                jjCheckNAddTwoStates(39, 28);
1788                            }
1789                            break;
1790    
1791                        case 40: // '('
1792                            if((0x3ff000000000000L & l1) != 0L)
1793                            {
1794                                if(i1 > 76)
1795                                    i1 = 76;
1796                                jjCheckNAddStates(17, 19);
1797                            }
1798                            break;
1799    
1800                        case 41: // ')'
1801                            if(curChar == '.')
1802                                jjCheckNAdd(42);
1803                            break;
1804    
1805                        case 42: // '*'
1806                            if((0x3ff000000000000L & l1) != 0L)
1807                            {
1808                                if(i1 > 76)
1809                                    i1 = 76;
1810                                jjCheckNAddTwoStates(42, 28);
1811                            }
1812                            break;
1813    
1814                        case 43: // '+'
1815                            if((0x3ff000000000000L & l1) != 0L)
1816                            {
1817                                if(i1 > 76)
1818                                    i1 = 76;
1819                                jjCheckNAddTwoStates(43, 44);
1820                            }
1821                            break;
1822    
1823                        case 44: // ','
1824                            if(curChar == '.')
1825                                jjCheckNAdd(45);
1826                            break;
1827    
1828                        case 45: // '-'
1829                            if((0x3ff000000000000L & l1) != 0L)
1830                            {
1831                                if(i1 > 76)
1832                                    i1 = 76;
1833                                jjCheckNAdd(45);
1834                            }
1835                            break;
1836    
1837                        case 46: // '.'
1838                            if((0x3ff000000000000L & l1) != 0L)
1839                            {
1840                                if(i1 > 76)
1841                                    i1 = 76;
1842                                jjCheckNAdd(46);
1843                            }
1844                            break;
1845                        }
1846                    while(l != k);
1847                } else
1848                if(curChar < '\200')
1849                {
1850                    long l2 = 1L << (curChar & 0x3f);
1851                    do
1852                        switch(jjstateSet[--l])
1853                        {
1854                        case 2: // '\002'
1855                        case 10: // '\n'
1856                            if((0x7fffffe07fffffeL & l2) != 0L)
1857                            {
1858                                if(i1 > 82)
1859                                    i1 = 82;
1860                                jjCheckNAddTwoStates(10, 11);
1861                            }
1862                            break;
1863    
1864                        case 48: // '0'
1865                            if((0x7fffffe87fffffeL & l2) != 0L)
1866                            {
1867                                if(i1 > 82)
1868                                    i1 = 82;
1869                                jjCheckNAdd(11);
1870                            }
1871                            if((0x7fffffe07fffffeL & l2) != 0L)
1872                            {
1873                                if(i1 > 82)
1874                                    i1 = 82;
1875                                jjCheckNAddTwoStates(10, 11);
1876                            }
1877                            break;
1878    
1879                        case 1: // '\001'
1880                            if(i1 > 80)
1881                                i1 = 80;
1882                            jjstateSet[jjnewStateCnt++] = 1;
1883                            break;
1884    
1885                        case 4: // '\004'
1886                            jjCheckNAddTwoStates(4, 5);
1887                            break;
1888    
1889                        case 6: // '\006'
1890                        case 7: // '\007'
1891                            jjCheckNAddTwoStates(7, 5);
1892                            break;
1893    
1894                        case 11: // '\013'
1895                            if((0x7fffffe87fffffeL & l2) != 0L)
1896                            {
1897                                if(i1 > 82)
1898                                    i1 = 82;
1899                                jjCheckNAdd(11);
1900                            }
1901                            break;
1902    
1903                        case 13: // '\r'
1904                            if((0x7fffffe07fffffeL & l2) != 0L)
1905                            {
1906                                if(i1 > 85)
1907                                    i1 = 85;
1908                                jjCheckNAddStates(20, 22);
1909                            }
1910                            break;
1911    
1912                        case 14: // '\016'
1913                            if((0x7fffffe87fffffeL & l2) != 0L)
1914                            {
1915                                if(i1 > 85)
1916                                    i1 = 85;
1917                                jjCheckNAddTwoStates(14, 15);
1918                            }
1919                            break;
1920    
1921                        case 16: // '\020'
1922                            if((0x7fffffe07fffffeL & l2) != 0L)
1923                            {
1924                                if(i1 > 85)
1925                                    i1 = 85;
1926                                jjCheckNAddTwoStates(16, 17);
1927                            }
1928                            break;
1929    
1930                        case 17: // '\021'
1931                            if((0x7fffffe87fffffeL & l2) != 0L)
1932                            {
1933                                if(i1 > 85)
1934                                    i1 = 85;
1935                                jjCheckNAdd(17);
1936                            }
1937                            break;
1938    
1939                        case 19: // '\023'
1940                            jjCheckNAddTwoStates(19, 20);
1941                            break;
1942    
1943                        case 22: // '\026'
1944                            jjCheckNAddTwoStates(22, 20);
1945                            break;
1946    
1947                        case 24: // '\030'
1948                            jjAddStates(23, 24);
1949                            break;
1950    
1951                        case 28: // '\034'
1952                            if((0x2000000020L & l2) != 0L)
1953                                jjAddStates(25, 27);
1954                            break;
1955                        }
1956                    while(l != k);
1957                } else
1958                {
1959                    int j1 = (curChar & 0xff) >> 6;
1960                    long l3 = 1L << (curChar & 0x3f);
1961                    do
1962                        switch(jjstateSet[--l])
1963                        {
1964                        case 1: // '\001'
1965                            if((jjbitVec0[j1] & l3) != 0L)
1966                            {
1967                                if(i1 > 80)
1968                                    i1 = 80;
1969                                jjstateSet[jjnewStateCnt++] = 1;
1970                            }
1971                            break;
1972    
1973                        case 4: // '\004'
1974                            if((jjbitVec0[j1] & l3) != 0L)
1975                                jjCheckNAddTwoStates(4, 5);
1976                            break;
1977    
1978                        case 6: // '\006'
1979                        case 7: // '\007'
1980                            if((jjbitVec0[j1] & l3) != 0L)
1981                                jjCheckNAddTwoStates(7, 5);
1982                            break;
1983    
1984                        case 19: // '\023'
1985                            if((jjbitVec0[j1] & l3) != 0L)
1986                                jjCheckNAddTwoStates(19, 20);
1987                            break;
1988    
1989                        case 22: // '\026'
1990                            if((jjbitVec0[j1] & l3) != 0L)
1991                                jjCheckNAddTwoStates(22, 20);
1992                            break;
1993    
1994                        case 24: // '\030'
1995                            if((jjbitVec0[j1] & l3) != 0L)
1996                                jjAddStates(23, 24);
1997                            break;
1998                        }
1999                    while(l != k);
2000                }
2001                if(i1 != 0x7fffffff)
2002                {
2003                    jjmatchedKind = i1;
2004                    jjmatchedPos = j;
2005                    i1 = 0x7fffffff;
2006                }
2007                j++;
2008                if((l = jjnewStateCnt) == (k = 47 - (jjnewStateCnt = k)))
2009                    return j;
2010                try
2011                {
2012                    curChar = input_stream.readChar();
2013                }
2014                catch(IOException ioexception)
2015                {
2016                    return j;
2017                }
2018            } while(true);
2019        }
2020    
2021        public ZqlJJParserTokenManager(SimpleCharStream simplecharstream)
2022        {
2023            debugStream = System.out;
2024            jjrounds = new int[47];
2025            jjstateSet = new int[94];
2026            curLexState = 0;
2027            defaultLexState = 0;
2028            input_stream = simplecharstream;
2029        }
2030    
2031        public ZqlJJParserTokenManager(SimpleCharStream simplecharstream, int i)
2032        {
2033            this(simplecharstream);
2034            SwitchTo(i);
2035        }
2036    
2037        public void ReInit(SimpleCharStream simplecharstream)
2038        {
2039            jjmatchedPos = jjnewStateCnt = 0;
2040            curLexState = defaultLexState;
2041            input_stream = simplecharstream;
2042            ReInitRounds();
2043        }
2044    
2045        private final void ReInitRounds()
2046        {
2047            jjround = 0x80000001;
2048            for(int i = 47; i-- > 0;)
2049                jjrounds[i] = 0x80000000;
2050    
2051        }
2052    
2053        public void ReInit(SimpleCharStream simplecharstream, int i)
2054        {
2055            ReInit(simplecharstream);
2056            SwitchTo(i);
2057        }
2058    
2059        public void SwitchTo(int i)
2060        {
2061            if(i >= 1 || i < 0)
2062            {
2063                throw new TokenMgrError("Error: Ignoring invalid lexical state : " + i + ". State unchanged.", 2);
2064            } 
2065            //else{
2066                curLexState = i;
2067                return;
2068            //}
2069        }
2070    
2071        private final Token jjFillToken()
2072        {
2073            Token token = Token.newToken(jjmatchedKind);
2074            token.kind = jjmatchedKind;
2075            String s = jjstrLiteralImages[jjmatchedKind];
2076            token.image = (s != null ? s : input_stream.GetImage());
2077            token.beginLine = input_stream.getBeginLine();
2078            token.beginColumn = input_stream.getBeginColumn();
2079            token.endLine = input_stream.getEndLine();
2080            token.endColumn = input_stream.getEndColumn();
2081            return token;
2082        }
2083    
2084        public final Token getNextToken()
2085        {
2086            Token token = null;
2087            int i = 0;
2088            do
2089            {
2090                try
2091                {
2092                    curChar = input_stream.BeginToken();
2093                }
2094                catch(IOException ioexception)
2095                {
2096                    jjmatchedKind = 0;
2097                    Token token1 = jjFillToken();
2098                    token1.specialToken = token;
2099                    return token1;
2100                }
2101                try
2102                {
2103                    input_stream.backup(0);
2104                    for(; curChar <= ' ' && (0x100002600L & 1L << curChar) != 0L; curChar = input_stream.BeginToken());
2105                }
2106                catch(IOException ioexception1)
2107                {
2108                    continue;
2109                }
2110                jjmatchedKind = 0x7fffffff;
2111                jjmatchedPos = 0;
2112                i = jjMoveStringLiteralDfa0_0();
2113                if(jjmatchedKind == 0x7fffffff)
2114                    break;
2115                if(jjmatchedPos + 1 < i)
2116                    input_stream.backup(i - jjmatchedPos - 1);
2117                if((jjtoToken[jjmatchedKind >> 6] & 1L << (jjmatchedKind & 0x3f)) != 0L)
2118                {
2119                    Token token2 = jjFillToken();
2120                    token2.specialToken = token;
2121                    return token2;
2122                }
2123                if((jjtoSpecial[jjmatchedKind >> 6] & 1L << (jjmatchedKind & 0x3f)) != 0L)
2124                {
2125                    Token token3 = jjFillToken();
2126                    if(token == null)
2127                    {
2128                        token = token3;
2129                    } else
2130                    {
2131                        token3.specialToken = token;
2132                        token = token.next = token3;
2133                    }
2134                }
2135            } while(true);
2136            int j = input_stream.getEndLine();
2137            int k = input_stream.getEndColumn();
2138            String s = null;
2139            boolean flag = false;
2140            try
2141            {
2142                input_stream.readChar();
2143                input_stream.backup(1);
2144            }
2145            catch(IOException ioexception2)
2146            {
2147                flag = true;
2148                s = i > 1 ? input_stream.GetImage() : "";
2149                if(curChar == '\n' || curChar == '\r')
2150                {
2151                    j++;
2152                    k = 0;
2153                } else
2154                {
2155                    k++;
2156                }
2157            }
2158            if(!flag)
2159            {
2160                input_stream.backup(1);
2161                s = i > 1 ? input_stream.GetImage() : "";
2162            }
2163            throw new TokenMgrError(flag, curLexState, j, k, s, curChar, 0);
2164        }
2165    
2166        public PrintStream debugStream;
2167        static final long jjbitVec0[] = {
2168            0L, 0L, -1L, -1L
2169        };
2170        static final int jjnextStates[] = {
2171            39, 40, 41, 28, 43, 44, 46, 5, 6, 8, 
2172            14, 15, 30, 32, 33, 34, 35, 40, 41, 28, 
2173            13, 14, 15, 24, 25, 29, 30, 32
2174        };
2175        public static final String jjstrLiteralImages[] = {
2176            "", null, null, null, null, null, null, null, null, null, 
2177            null, null, null, null, null, null, null, null, null, null, 
2178            null, null, null, null, null, null, null, null, null, null, 
2179            null, null, null, null, null, null, null, null, null, null, 
2180            null, null, null, null, null, null, null, null, null, null, 
2181            null, null, null, null, null, null, null, null, null, null, 
2182            null, null, null, null, null, null, null, null, null, null, 
2183            null, null, null, null, null, null, null, null, null, null, 
2184            null, null, null, null, null, null, null, null, "(", ",", 
2185            ")", ";", "=", ".", "!=", "#", "<>", ">", ">=", "<", 
2186            "<=", "+", "-", "*", ".*", "?", "||", "/", "**"
2187        };
2188        public static final String lexStateNames[] = {
2189            "DEFAULT"
2190        };
2191        static final long jjtoToken[] = {
2192            -31L, 0x1fffffe41fffL
2193        };
2194        static final long jjtoSkip[] = {
2195            30L, 0x30000L
2196        };
2197        static final long jjtoSpecial[] = {
2198            0L, 0x30000L
2199        };
2200        private SimpleCharStream input_stream;
2201        private final int jjrounds[];
2202        private final int jjstateSet[];
2203        protected char curChar;
2204        int curLexState;
2205        int defaultLexState;
2206        int jjnewStateCnt;
2207        int jjround;
2208        int jjmatchedPos;
2209        int jjmatchedKind;
2210    
2211    }