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