001    /* Generated By:JavaCC: Do not edit this line. ParserTokenManager.java */
002    package edu.upenn.gloDB.parser;
003    import edu.upenn.gloDB.*;
004    import java.io.StringReader;
005    import java.util.HashMap;
006    import java.util.HashSet;
007    import java.util.ArrayList;
008    import java.util.Iterator;
009    
010    public class ParserTokenManager implements ParserConstants
011    {
012      public  java.io.PrintStream debugStream = System.out;
013      public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
014    private final int jjStopStringLiteralDfa_0(int pos, long active0)
015    {
016       switch (pos)
017       {
018          case 0:
019             if ((active0 & 0x100000000L) != 0L)
020                return 2;
021             if ((active0 & 0x24000000L) != 0L)
022             {
023                jjmatchedKind = 43;
024                return 22;
025             }
026             if ((active0 & 0x3c011000004L) != 0L)
027             {
028                jjmatchedKind = 43;
029                return 99;
030             }
031             if ((active0 & 0x8L) != 0L)
032             {
033                jjmatchedKind = 43;
034                return 30;
035             }
036             if ((active0 & 0x1000L) != 0L)
037                return 100;
038             if ((active0 & 0x8000000L) != 0L)
039             {
040                jjmatchedKind = 43;
041                return 19;
042             }
043             if ((active0 & 0x2000000L) != 0L)
044             {
045                jjmatchedKind = 43;
046                return 75;
047             }
048             return -1;
049          case 1:
050             if ((active0 & 0x3c03700000cL) != 0L)
051             {
052                jjmatchedKind = 43;
053                jjmatchedPos = 1;
054                return 99;
055             }
056             if ((active0 & 0x8000000L) != 0L)
057                return 99;
058             return -1;
059          case 2:
060             if ((active0 & 0x3000000L) != 0L)
061                return 99;
062             if ((active0 & 0x3c03400000cL) != 0L)
063             {
064                if (jjmatchedPos != 2)
065                {
066                   jjmatchedKind = 43;
067                   jjmatchedPos = 2;
068                }
069                return 99;
070             }
071             return -1;
072          case 3:
073             if ((active0 & 0x3c030000008L) != 0L)
074             {
075                jjmatchedKind = 43;
076                jjmatchedPos = 3;
077                return 99;
078             }
079             if ((active0 & 0x4000004L) != 0L)
080                return 99;
081             return -1;
082          case 4:
083             if ((active0 & 0x34020000008L) != 0L)
084             {
085                jjmatchedKind = 43;
086                jjmatchedPos = 4;
087                return 99;
088             }
089             if ((active0 & 0x8010000000L) != 0L)
090                return 99;
091             return -1;
092          case 5:
093             if ((active0 & 0x4020000000L) != 0L)
094                return 99;
095             if ((active0 & 0x30000000008L) != 0L)
096             {
097                jjmatchedKind = 43;
098                jjmatchedPos = 5;
099                return 99;
100             }
101             return -1;
102          case 6:
103             if ((active0 & 0x30000000008L) != 0L)
104             {
105                jjmatchedKind = 43;
106                jjmatchedPos = 6;
107                return 99;
108             }
109             return -1;
110          case 7:
111             if ((active0 & 0x20000000008L) != 0L)
112             {
113                jjmatchedKind = 43;
114                jjmatchedPos = 7;
115                return 99;
116             }
117             if ((active0 & 0x10000000000L) != 0L)
118                return 99;
119             return -1;
120          case 8:
121             if ((active0 & 0x8L) != 0L)
122             {
123                if (jjmatchedPos < 7)
124                {
125                   jjmatchedKind = 43;
126                   jjmatchedPos = 7;
127                }
128                return 101;
129             }
130             if ((active0 & 0x20000000000L) != 0L)
131                return 99;
132             return -1;
133          case 9:
134             if ((active0 & 0x8L) != 0L)
135             {
136                if (jjmatchedPos < 7)
137                {
138                   jjmatchedKind = 43;
139                   jjmatchedPos = 7;
140                }
141                return -1;
142             }
143             return -1;
144          default :
145             return -1;
146       }
147    }
148    private final int jjStartNfa_0(int pos, long active0)
149    {
150       return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
151    }
152    private final int jjStopAtPos(int pos, int kind)
153    {
154       jjmatchedKind = kind;
155       jjmatchedPos = pos;
156       return pos + 1;
157    }
158    private final int jjStartNfaWithStates_0(int pos, int kind, int state)
159    {
160       jjmatchedKind = kind;
161       jjmatchedPos = pos;
162       try { curChar = input_stream.readChar(); }
163       catch(java.io.IOException e) { return pos + 1; }
164       return jjMoveNfa_0(state, pos + 1);
165    }
166    private final int jjMoveStringLiteralDfa0_0()
167    {
168       switch(curChar)
169       {
170          case 10:
171             return jjStopAtPos(0, 37);
172          case 33:
173             return jjStopAtPos(0, 33);
174          case 38:
175             return jjMoveStringLiteralDfa1_0(0x40000000L);
176          case 40:
177             return jjStopAtPos(0, 19);
178          case 41:
179             return jjStopAtPos(0, 20);
180          case 42:
181             return jjStopAtPos(0, 36);
182          case 43:
183             return jjStopAtPos(0, 35);
184          case 44:
185             return jjStopAtPos(0, 9);
186          case 45:
187             return jjStartNfaWithStates_0(0, 32, 2);
188          case 59:
189             return jjStopAtPos(0, 47);
190          case 60:
191             return jjStartNfaWithStates_0(0, 12, 100);
192          case 61:
193             return jjStopAtPos(0, 8);
194          case 62:
195             return jjStopAtPos(0, 14);
196          case 63:
197             return jjStopAtPos(0, 34);
198          case 91:
199             return jjStopAtPos(0, 21);
200          case 93:
201             return jjStopAtPos(0, 22);
202          case 65:
203          case 97:
204             return jjMoveStringLiteralDfa1_0(0x2000000L);
205          case 70:
206          case 102:
207             return jjMoveStringLiteralDfa1_0(0x8L);
208          case 77:
209          case 109:
210             return jjMoveStringLiteralDfa1_0(0x10000000L);
211          case 79:
212          case 111:
213             return jjMoveStringLiteralDfa1_0(0x8000000L);
214          case 80:
215          case 112:
216             return jjMoveStringLiteralDfa1_0(0x20001000000L);
217          case 82:
218          case 114:
219             return jjMoveStringLiteralDfa1_0(0x10000000000L);
220          case 83:
221          case 115:
222             return jjMoveStringLiteralDfa1_0(0x24000000L);
223          case 84:
224          case 116:
225             return jjMoveStringLiteralDfa1_0(0x8000000004L);
226          case 87:
227          case 119:
228             return jjMoveStringLiteralDfa1_0(0x4000000000L);
229          case 123:
230             return jjStopAtPos(0, 17);
231          case 124:
232             return jjMoveStringLiteralDfa1_0(0x80000000L);
233          case 125:
234             return jjStopAtPos(0, 18);
235          case 126:
236             return jjStopAtPos(0, 23);
237          default :
238             return jjMoveNfa_0(1, 0);
239       }
240    }
241    private final int jjMoveStringLiteralDfa1_0(long active0)
242    {
243       try { curChar = input_stream.readChar(); }
244       catch(java.io.IOException e) {
245          jjStopStringLiteralDfa_0(0, active0);
246          return 1;
247       }
248       switch(curChar)
249       {
250          case 38:
251             if ((active0 & 0x40000000L) != 0L)
252                return jjStopAtPos(1, 30);
253             break;
254          case 65:
255          case 97:
256             return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
257          case 69:
258          case 101:
259             return jjMoveStringLiteralDfa2_0(active0, 0x10000000000L);
260          case 72:
261          case 104:
262             return jjMoveStringLiteralDfa2_0(active0, 0x4L);
263          case 73:
264          case 105:
265             return jjMoveStringLiteralDfa2_0(active0, 0xc010000000L);
266          case 77:
267          case 109:
268             return jjMoveStringLiteralDfa2_0(active0, 0x20000000L);
269          case 78:
270          case 110:
271             return jjMoveStringLiteralDfa2_0(active0, 0x2000000L);
272          case 79:
273          case 111:
274             return jjMoveStringLiteralDfa2_0(active0, 0x20001000008L);
275          case 82:
276          case 114:
277             if ((active0 & 0x8000000L) != 0L)
278                return jjStartNfaWithStates_0(1, 27, 99);
279             break;
280          case 124:
281             if ((active0 & 0x80000000L) != 0L)
282                return jjStopAtPos(1, 31);
283             break;
284          default :
285             break;
286       }
287       return jjStartNfa_0(0, active0);
288    }
289    private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
290    {
291       if (((active0 &= old0)) == 0L)
292          return jjStartNfa_0(0, old0); 
293       try { curChar = input_stream.readChar(); }
294       catch(java.io.IOException e) {
295          jjStopStringLiteralDfa_0(1, active0);
296          return 2;
297       }
298       switch(curChar)
299       {
300          case 68:
301          case 100:
302             if ((active0 & 0x2000000L) != 0L)
303                return jjStartNfaWithStates_0(2, 25, 99);
304             break;
305          case 69:
306          case 101:
307             return jjMoveStringLiteralDfa3_0(active0, 0x4L);
308          case 73:
309          case 105:
310             return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
311          case 76:
312          case 108:
313             return jjMoveStringLiteralDfa3_0(active0, 0x8L);
314          case 77:
315          case 109:
316             return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L);
317          case 78:
318          case 110:
319             return jjMoveStringLiteralDfa3_0(active0, 0x14000000L);
320          case 80:
321          case 112:
322             return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L);
323          case 83:
324          case 115:
325             if ((active0 & 0x1000000L) != 0L)
326             {
327                jjmatchedKind = 24;
328                jjmatchedPos = 2;
329             }
330             return jjMoveStringLiteralDfa3_0(active0, 0x20000000000L);
331          case 84:
332          case 116:
333             return jjMoveStringLiteralDfa3_0(active0, 0x4000000000L);
334          default :
335             break;
336       }
337       return jjStartNfa_0(1, active0);
338    }
339    private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
340    {
341       if (((active0 &= old0)) == 0L)
342          return jjStartNfa_0(1, old0); 
343       try { curChar = input_stream.readChar(); }
344       catch(java.io.IOException e) {
345          jjStopStringLiteralDfa_0(2, active0);
346          return 3;
347       }
348       switch(curChar)
349       {
350          case 68:
351          case 100:
352             if ((active0 & 0x4000000L) != 0L)
353                return jjStartNfaWithStates_0(3, 26, 99);
354             break;
355          case 69:
356          case 101:
357             return jjMoveStringLiteralDfa4_0(active0, 0x18000000000L);
358          case 72:
359          case 104:
360             return jjMoveStringLiteralDfa4_0(active0, 0x4000000000L);
361          case 73:
362          case 105:
363             return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L);
364          case 76:
365          case 108:
366             return jjMoveStringLiteralDfa4_0(active0, 0x8L);
367          case 78:
368          case 110:
369             if ((active0 & 0x4L) != 0L)
370                return jjStartNfaWithStates_0(3, 2, 99);
371             return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
372          case 85:
373          case 117:
374             return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);
375          default :
376             break;
377       }
378       return jjStartNfa_0(2, active0);
379    }
380    private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
381    {
382       if (((active0 &= old0)) == 0L)
383          return jjStartNfa_0(2, old0); 
384       try { curChar = input_stream.readChar(); }
385       catch(java.io.IOException e) {
386          jjStopStringLiteralDfa_0(3, active0);
387          return 4;
388       }
389       switch(curChar)
390       {
391          case 65:
392          case 97:
393             return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);
394          case 73:
395          case 105:
396             return jjMoveStringLiteralDfa5_0(active0, 0x4000000000L);
397          case 79:
398          case 111:
399             return jjMoveStringLiteralDfa5_0(active0, 0x8L);
400          case 83:
401          case 115:
402             if ((active0 & 0x10000000L) != 0L)
403                return jjStartNfaWithStates_0(4, 28, 99);
404             else if ((active0 & 0x8000000000L) != 0L)
405                return jjStartNfaWithStates_0(4, 39, 99);
406             break;
407          case 84:
408          case 116:
409             return jjMoveStringLiteralDfa5_0(active0, 0x20000000000L);
410          case 85:
411          case 117:
412             return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
413          default :
414             break;
415       }
416       return jjStartNfa_0(3, active0);
417    }
418    private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
419    {
420       if (((active0 &= old0)) == 0L)
421          return jjStartNfa_0(3, old0); 
422       try { curChar = input_stream.readChar(); }
423       catch(java.io.IOException e) {
424          jjStopStringLiteralDfa_0(4, active0);
425          return 5;
426       }
427       switch(curChar)
428       {
429          case 73:
430          case 105:
431             return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L);
432          case 78:
433          case 110:
434             if ((active0 & 0x4000000000L) != 0L)
435                return jjStartNfaWithStates_0(5, 38, 99);
436             break;
437          case 83:
438          case 115:
439             if ((active0 & 0x20000000L) != 0L)
440                return jjStartNfaWithStates_0(5, 29, 99);
441             break;
442          case 84:
443          case 116:
444             return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L);
445          case 87:
446          case 119:
447             return jjMoveStringLiteralDfa6_0(active0, 0x8L);
448          default :
449             break;
450       }
451       return jjStartNfa_0(4, active0);
452    }
453    private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
454    {
455       if (((active0 &= old0)) == 0L)
456          return jjStartNfa_0(4, old0); 
457       try { curChar = input_stream.readChar(); }
458       catch(java.io.IOException e) {
459          jjStopStringLiteralDfa_0(5, active0);
460          return 6;
461       }
462       switch(curChar)
463       {
464          case 69:
465          case 101:
466             return jjMoveStringLiteralDfa7_0(active0, 0x10000000008L);
467          case 79:
468          case 111:
469             return jjMoveStringLiteralDfa7_0(active0, 0x20000000000L);
470          default :
471             break;
472       }
473       return jjStartNfa_0(5, active0);
474    }
475    private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
476    {
477       if (((active0 &= old0)) == 0L)
478          return jjStartNfa_0(5, old0); 
479       try { curChar = input_stream.readChar(); }
480       catch(java.io.IOException e) {
481          jjStopStringLiteralDfa_0(6, active0);
482          return 7;
483       }
484       switch(curChar)
485       {
486          case 68:
487          case 100:
488             if ((active0 & 0x10000000000L) != 0L)
489                return jjStartNfaWithStates_0(7, 40, 99);
490             return jjMoveStringLiteralDfa8_0(active0, 0x8L);
491          case 78:
492          case 110:
493             return jjMoveStringLiteralDfa8_0(active0, 0x20000000000L);
494          default :
495             break;
496       }
497       return jjStartNfa_0(6, active0);
498    }
499    private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
500    {
501       if (((active0 &= old0)) == 0L)
502          return jjStartNfa_0(6, old0); 
503       try { curChar = input_stream.readChar(); }
504       catch(java.io.IOException e) {
505          jjStopStringLiteralDfa_0(7, active0);
506          return 8;
507       }
508       switch(curChar)
509       {
510          case 32:
511             return jjMoveStringLiteralDfa9_0(active0, 0x8L);
512          case 83:
513          case 115:
514             if ((active0 & 0x20000000000L) != 0L)
515                return jjStartNfaWithStates_0(8, 41, 99);
516             break;
517          default :
518             break;
519       }
520       return jjStartNfa_0(7, active0);
521    }
522    private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
523    {
524       if (((active0 &= old0)) == 0L)
525          return jjStartNfa_0(7, old0); 
526       try { curChar = input_stream.readChar(); }
527       catch(java.io.IOException e) {
528          jjStopStringLiteralDfa_0(8, active0);
529          return 9;
530       }
531       switch(curChar)
532       {
533          case 66:
534          case 98:
535             return jjMoveStringLiteralDfa10_0(active0, 0x8L);
536          default :
537             break;
538       }
539       return jjStartNfa_0(8, active0);
540    }
541    private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
542    {
543       if (((active0 &= old0)) == 0L)
544          return jjStartNfa_0(8, old0); 
545       try { curChar = input_stream.readChar(); }
546       catch(java.io.IOException e) {
547          jjStopStringLiteralDfa_0(9, active0);
548          return 10;
549       }
550       switch(curChar)
551       {
552          case 89:
553          case 121:
554             if ((active0 & 0x8L) != 0L)
555                return jjStopAtPos(10, 3);
556             break;
557          default :
558             break;
559       }
560       return jjStartNfa_0(9, active0);
561    }
562    private final void jjCheckNAdd(int state)
563    {
564       if (jjrounds[state] != jjround)
565       {
566          jjstateSet[jjnewStateCnt++] = state;
567          jjrounds[state] = jjround;
568       }
569    }
570    private final void jjAddStates(int start, int end)
571    {
572       do {
573          jjstateSet[jjnewStateCnt++] = jjnextStates[start];
574       } while (start++ != end);
575    }
576    private final void jjCheckNAddTwoStates(int state1, int state2)
577    {
578       jjCheckNAdd(state1);
579       jjCheckNAdd(state2);
580    }
581    private final void jjCheckNAddStates(int start, int end)
582    {
583       do {
584          jjCheckNAdd(jjnextStates[start]);
585       } while (start++ != end);
586    }
587    private final void jjCheckNAddStates(int start)
588    {
589       jjCheckNAdd(jjnextStates[start]);
590       jjCheckNAdd(jjnextStates[start + 1]);
591    }
592    private final int jjMoveNfa_0(int startState, int curPos)
593    {
594       int[] nextStates;
595       int startsAt = 0;
596       jjnewStateCnt = 99;
597       int i = 1;
598       jjstateSet[0] = startState;
599       int j, kind = 0x7fffffff;
600       for (;;)
601       {
602          if (++jjround == 0x7fffffff)
603             ReInitRounds();
604          if (curChar < 64)
605          {
606             long l = 1L << curChar;
607             MatchLoop: do
608             {
609                switch(jjstateSet[--i])
610                {
611                   case 30:
612                      if ((0x3ff200000000000L & l) != 0L)
613                         jjCheckNAddStates(0, 2);
614                      else if (curChar == 61)
615                      {
616                         if (kind > 44)
617                            kind = 44;
618                      }
619                      else if (curChar == 32)
620                         jjCheckNAddTwoStates(97, 98);
621                      if ((0x3ff200000000000L & l) != 0L)
622                      {
623                         if (kind > 43)
624                            kind = 43;
625                         jjCheckNAdd(95);
626                      }
627                      break;
628                   case 101:
629                      if (curChar == 61)
630                      {
631                         if (kind > 44)
632                            kind = 44;
633                      }
634                      else if (curChar == 32)
635                         jjCheckNAddTwoStates(97, 98);
636                      break;
637                   case 100:
638                      if (curChar == 59)
639                      {
640                         if (kind > 13)
641                            kind = 13;
642                      }
643                      else if (curChar == 32)
644                         jjCheckNAddTwoStates(4, 5);
645                      break;
646                   case 75:
647                      if ((0x3ff200000000000L & l) != 0L)
648                         jjCheckNAddStates(0, 2);
649                      else if (curChar == 32)
650                         jjstateSet[jjnewStateCnt++] = 92;
651                      else if (curChar == 61)
652                      {
653                         if (kind > 44)
654                            kind = 44;
655                      }
656                      if ((0x3ff200000000000L & l) != 0L)
657                      {
658                         if (kind > 43)
659                            kind = 43;
660                         jjCheckNAdd(95);
661                      }
662                      else if (curChar == 32)
663                         jjCheckNAddTwoStates(97, 98);
664                      if (curChar == 32)
665                         jjstateSet[jjnewStateCnt++] = 74;
666                      break;
667                   case 19:
668                      if ((0x3ff200000000000L & l) != 0L)
669                         jjCheckNAddStates(0, 2);
670                      else if (curChar == 61)
671                      {
672                         if (kind > 44)
673                            kind = 44;
674                      }
675                      else if (curChar == 32)
676                         jjCheckNAddTwoStates(97, 98);
677                      if ((0x3ff200000000000L & l) != 0L)
678                      {
679                         if (kind > 43)
680                            kind = 43;
681                         jjCheckNAdd(95);
682                      }
683                      break;
684                   case 22:
685                      if ((0x3ff200000000000L & l) != 0L)
686                         jjCheckNAddStates(0, 2);
687                      else if (curChar == 58)
688                      {
689                         if (kind > 46)
690                            kind = 46;
691                         jjCheckNAdd(23);
692                      }
693                      else if (curChar == 61)
694                      {
695                         if (kind > 44)
696                            kind = 44;
697                      }
698                      else if (curChar == 32)
699                         jjCheckNAddTwoStates(97, 98);
700                      if ((0x3ff200000000000L & l) != 0L)
701                      {
702                         if (kind > 43)
703                            kind = 43;
704                         jjCheckNAdd(95);
705                      }
706                      break;
707                   case 99:
708                      if ((0x3ff200000000000L & l) != 0L)
709                         jjCheckNAddStates(0, 2);
710                      else if (curChar == 61)
711                      {
712                         if (kind > 44)
713                            kind = 44;
714                      }
715                      else if (curChar == 32)
716                         jjCheckNAddTwoStates(97, 98);
717                      if ((0x3ff200000000000L & l) != 0L)
718                      {
719                         if (kind > 43)
720                            kind = 43;
721                         jjCheckNAdd(95);
722                      }
723                      break;
724                   case 1:
725                      if ((0x3ff000000000000L & l) != 0L)
726                      {
727                         if (kind > 10)
728                            kind = 10;
729                         jjCheckNAdd(0);
730                      }
731                      else if (curChar == 60)
732                         jjCheckNAddTwoStates(4, 5);
733                      else if (curChar == 45)
734                         jjCheckNAdd(2);
735                      break;
736                   case 0:
737                      if ((0x3ff000000000000L & l) == 0L)
738                         break;
739                      if (kind > 10)
740                         kind = 10;
741                      jjCheckNAdd(0);
742                      break;
743                   case 2:
744                      if ((0x3ff000000000000L & l) == 0L)
745                         break;
746                      if (kind > 11)
747                         kind = 11;
748                      jjCheckNAdd(2);
749                      break;
750                   case 3:
751                      if (curChar == 60)
752                         jjCheckNAddTwoStates(4, 5);
753                      break;
754                   case 4:
755                      if (curChar == 32)
756                         jjCheckNAddTwoStates(4, 5);
757                      break;
758                   case 5:
759                      if (curChar == 59)
760                         kind = 13;
761                      break;
762                   case 10:
763                      if (curChar != 32)
764                         break;
765                      if (kind > 46)
766                         kind = 46;
767                      jjstateSet[jjnewStateCnt++] = 10;
768                      break;
769                   case 18:
770                      if (curChar == 32)
771                         jjstateSet[jjnewStateCnt++] = 17;
772                      break;
773                   case 23:
774                      if (curChar != 32)
775                         break;
776                      if (kind > 46)
777                         kind = 46;
778                      jjCheckNAdd(23);
779                      break;
780                   case 25:
781                      if (curChar != 32)
782                         break;
783                      if (kind > 46)
784                         kind = 46;
785                      jjstateSet[jjnewStateCnt++] = 25;
786                      break;
787                   case 39:
788                      if (curChar == 32)
789                         jjstateSet[jjnewStateCnt++] = 38;
790                      break;
791                   case 48:
792                      if (curChar == 32)
793                         jjstateSet[jjnewStateCnt++] = 47;
794                      break;
795                   case 60:
796                      if (curChar == 32)
797                         jjstateSet[jjnewStateCnt++] = 59;
798                      break;
799                   case 64:
800                      if (curChar == 32)
801                         jjstateSet[jjnewStateCnt++] = 63;
802                      break;
803                   case 67:
804                      if (curChar == 32)
805                         jjstateSet[jjnewStateCnt++] = 66;
806                      break;
807                   case 77:
808                      if (curChar != 32)
809                         break;
810                      if (kind > 45)
811                         kind = 45;
812                      jjstateSet[jjnewStateCnt++] = 77;
813                      break;
814                   case 82:
815                      if (curChar == 32)
816                         jjstateSet[jjnewStateCnt++] = 81;
817                      break;
818                   case 85:
819                      if (curChar == 32)
820                         jjstateSet[jjnewStateCnt++] = 84;
821                      break;
822                   case 93:
823                      if (curChar == 32)
824                         jjstateSet[jjnewStateCnt++] = 92;
825                      break;
826                   case 95:
827                      if ((0x3ff200000000000L & l) == 0L)
828                         break;
829                      if (kind > 43)
830                         kind = 43;
831                      jjCheckNAdd(95);
832                      break;
833                   case 96:
834                      if ((0x3ff200000000000L & l) != 0L)
835                         jjCheckNAddStates(0, 2);
836                      break;
837                   case 97:
838                      if (curChar == 32)
839                         jjCheckNAddTwoStates(97, 98);
840                      break;
841                   case 98:
842                      if (curChar == 61)
843                         kind = 44;
844                      break;
845                   default : break;
846                }
847             } while(i != startsAt);
848          }
849          else if (curChar < 128)
850          {
851             long l = 1L << (curChar & 077);
852             MatchLoop: do
853             {
854                switch(jjstateSet[--i])
855                {
856                   case 30:
857                      if ((0x7fffffe87fffffeL & l) != 0L)
858                         jjCheckNAddStates(0, 2);
859                      if ((0x7fffffe87fffffeL & l) != 0L)
860                      {
861                         if (kind > 43)
862                            kind = 43;
863                         jjCheckNAdd(95);
864                      }
865                      if ((0x4000000040000L & l) != 0L)
866                         jjstateSet[jjnewStateCnt++] = 41;
867                      if ((0x4000000040000L & l) != 0L)
868                         jjstateSet[jjnewStateCnt++] = 29;
869                      break;
870                   case 75:
871                      if ((0x7fffffe87fffffeL & l) != 0L)
872                         jjCheckNAddStates(0, 2);
873                      if ((0x7fffffe87fffffeL & l) != 0L)
874                      {
875                         if (kind > 43)
876                            kind = 43;
877                         jjCheckNAdd(95);
878                      }
879                      break;
880                   case 19:
881                      if ((0x7fffffe87fffffeL & l) != 0L)
882                         jjCheckNAddStates(0, 2);
883                      if ((0x7fffffe87fffffeL & l) != 0L)
884                      {
885                         if (kind > 43)
886                            kind = 43;
887                         jjCheckNAdd(95);
888                      }
889                      if ((0x400000004000L & l) != 0L)
890                         jjstateSet[jjnewStateCnt++] = 18;
891                      break;
892                   case 22:
893                      if ((0x7fffffe87fffffeL & l) != 0L)
894                         jjCheckNAddStates(0, 2);
895                      if ((0x7fffffe87fffffeL & l) != 0L)
896                      {
897                         if (kind > 43)
898                            kind = 43;
899                         jjCheckNAdd(95);
900                      }
901                      if ((0x2000000020L & l) != 0L)
902                         jjstateSet[jjnewStateCnt++] = 24;
903                      break;
904                   case 99:
905                      if ((0x7fffffe87fffffeL & l) != 0L)
906                         jjCheckNAddStates(0, 2);
907                      if ((0x7fffffe87fffffeL & l) != 0L)
908                      {
909                         if (kind > 43)
910                            kind = 43;
911                         jjCheckNAdd(95);
912                      }
913                      break;
914                   case 1:
915                      if ((0x7fffffe87fffffeL & l) != 0L)
916                      {
917                         if (kind > 43)
918                            kind = 43;
919                         jjCheckNAddStates(3, 6);
920                      }
921                      if ((0x200000002L & l) != 0L)
922                         jjAddStates(7, 8);
923                      else if ((0x100000001000L & l) != 0L)
924                         jjAddStates(9, 10);
925                      else if ((0x4000000040L & l) != 0L)
926                         jjAddStates(11, 12);
927                      else if ((0x8000000080000L & l) != 0L)
928                         jjAddStates(13, 14);
929                      else if ((0x800000008000L & l) != 0L)
930                         jjstateSet[jjnewStateCnt++] = 19;
931                      else if (curChar == 95)
932                         jjstateSet[jjnewStateCnt++] = 7;
933                      break;
934                   case 6:
935                      if ((0x10000000100000L & l) != 0L && kind > 42)
936                         kind = 42;
937                      break;
938                   case 7:
939                      if (curChar == 95)
940                         jjstateSet[jjnewStateCnt++] = 6;
941                      break;
942                   case 8:
943                      if (curChar == 95)
944                         jjstateSet[jjnewStateCnt++] = 7;
945                      break;
946                   case 9:
947                      if ((0x2000000020L & l) != 0L)
948                         jjstateSet[jjnewStateCnt++] = 10;
949                      break;
950                   case 11:
951                      if ((0x800000008L & l) != 0L)
952                         jjstateSet[jjnewStateCnt++] = 9;
953                      break;
954                   case 12:
955                      if ((0x400000004000L & l) != 0L)
956                         jjstateSet[jjnewStateCnt++] = 11;
957                      break;
958                   case 13:
959                      if ((0x2000000020L & l) != 0L)
960                         jjstateSet[jjnewStateCnt++] = 12;
961                      break;
962                   case 14:
963                      if ((0x20000000200000L & l) != 0L)
964                         jjstateSet[jjnewStateCnt++] = 13;
965                      break;
966                   case 15:
967                      if ((0x2000000020000L & l) != 0L)
968                         jjstateSet[jjnewStateCnt++] = 14;
969                      break;
970                   case 16:
971                      if ((0x2000000020L & l) != 0L)
972                         jjstateSet[jjnewStateCnt++] = 15;
973                      break;
974                   case 17:
975                      if ((0x8000000080000L & l) != 0L)
976                         jjstateSet[jjnewStateCnt++] = 16;
977                      break;
978                   case 20:
979                      if ((0x800000008000L & l) != 0L)
980                         jjstateSet[jjnewStateCnt++] = 19;
981                      break;
982                   case 21:
983                      if ((0x8000000080000L & l) != 0L)
984                         jjAddStates(13, 14);
985                      break;
986                   case 24:
987                      if ((0x2000000020000L & l) != 0L)
988                         jjstateSet[jjnewStateCnt++] = 25;
989                      break;
990                   case 26:
991                      if ((0x2000000020L & l) != 0L)
992                         jjstateSet[jjnewStateCnt++] = 24;
993                      break;
994                   case 27:
995                      if ((0x4000000040L & l) != 0L)
996                         jjAddStates(11, 12);
997                      break;
998                   case 28:
999                      if ((0x200000002000L & l) != 0L && kind > 16)
1000                         kind = 16;
1001                      break;
1002                   case 29:
1003                      if ((0x800000008000L & l) != 0L)
1004                         jjstateSet[jjnewStateCnt++] = 28;
1005                      break;
1006                   case 31:
1007                      if ((0x400000004000L & l) != 0L && kind > 16)
1008                         kind = 16;
1009                      break;
1010                   case 32:
1011                      if ((0x800000008000L & l) != 0L)
1012                         jjstateSet[jjnewStateCnt++] = 31;
1013                      break;
1014                   case 33:
1015                      if ((0x20000000200L & l) != 0L)
1016                         jjstateSet[jjnewStateCnt++] = 32;
1017                      break;
1018                   case 34:
1019                      if ((0x10000000100000L & l) != 0L)
1020                         jjstateSet[jjnewStateCnt++] = 33;
1021                      break;
1022                   case 35:
1023                      if ((0x20000000200L & l) != 0L)
1024                         jjstateSet[jjnewStateCnt++] = 34;
1025                      break;
1026                   case 36:
1027                      if ((0x8000000080000L & l) != 0L)
1028                         jjstateSet[jjnewStateCnt++] = 35;
1029                      break;
1030                   case 37:
1031                      if ((0x800000008000L & l) != 0L)
1032                         jjstateSet[jjnewStateCnt++] = 36;
1033                      break;
1034                   case 38:
1035                      if ((0x1000000010000L & l) != 0L)
1036                         jjstateSet[jjnewStateCnt++] = 37;
1037                      break;
1038                   case 40:
1039                      if ((0x200000002000L & l) != 0L)
1040                         jjstateSet[jjnewStateCnt++] = 39;
1041                      break;
1042                   case 41:
1043                      if ((0x800000008000L & l) != 0L)
1044                         jjstateSet[jjnewStateCnt++] = 40;
1045                      break;
1046                   case 42:
1047                      if ((0x4000000040000L & l) != 0L)
1048                         jjstateSet[jjnewStateCnt++] = 41;
1049                      break;
1050                   case 43:
1051                      if ((0x100000001000L & l) != 0L)
1052                         jjAddStates(9, 10);
1053                      break;
1054                   case 44:
1055                      if ((0x400000004000L & l) != 0L && kind > 15)
1056                         kind = 15;
1057                      break;
1058                   case 45:
1059                      if ((0x2000000020L & l) != 0L)
1060                         jjstateSet[jjnewStateCnt++] = 44;
1061                      break;
1062                   case 46:
1063                      if ((0x4000000040L & l) != 0L && kind > 15)
1064                         kind = 15;
1065                      break;
1066                   case 47:
1067                      if ((0x800000008000L & l) != 0L)
1068                         jjstateSet[jjnewStateCnt++] = 46;
1069                      break;
1070                   case 49:
1071                      if ((0x10000000100L & l) != 0L)
1072                         jjstateSet[jjnewStateCnt++] = 48;
1073                      break;
1074                   case 50:
1075                      if ((0x10000000100000L & l) != 0L)
1076                         jjstateSet[jjnewStateCnt++] = 49;
1077                      break;
1078                   case 51:
1079                      if ((0x8000000080L & l) != 0L)
1080                         jjstateSet[jjnewStateCnt++] = 50;
1081                      break;
1082                   case 52:
1083                      if ((0x400000004000L & l) != 0L)
1084                         jjstateSet[jjnewStateCnt++] = 51;
1085                      break;
1086                   case 53:
1087                      if ((0x2000000020L & l) != 0L)
1088                         jjstateSet[jjnewStateCnt++] = 52;
1089                      break;
1090                   case 54:
1091                      if ((0x200000002L & l) != 0L)
1092                         jjAddStates(7, 8);
1093                      break;
1094                   case 55:
1095                      if ((0x80000000800L & l) != 0L && kind > 42)
1096                         kind = 42;
1097                      break;
1098                   case 56:
1099                      if ((0x800000008L & l) != 0L)
1100                         jjstateSet[jjnewStateCnt++] = 55;
1101                      break;
1102                   case 57:
1103                      if ((0x200000002L & l) != 0L)
1104                         jjstateSet[jjnewStateCnt++] = 56;
1105                      break;
1106                   case 58:
1107                      if ((0x4000000040000L & l) != 0L)
1108                         jjstateSet[jjnewStateCnt++] = 57;
1109                      break;
1110                   case 59:
1111                      if ((0x10000000100000L & l) != 0L)
1112                         jjstateSet[jjnewStateCnt++] = 58;
1113                      break;
1114                   case 61:
1115                      if ((0x200000002000000L & l) != 0L)
1116                         jjstateSet[jjnewStateCnt++] = 60;
1117                      break;
1118                   case 62:
1119                      if ((0x400000004000L & l) != 0L)
1120                         jjstateSet[jjnewStateCnt++] = 61;
1121                      break;
1122                   case 63:
1123                      if ((0x200000002L & l) != 0L)
1124                         jjstateSet[jjnewStateCnt++] = 62;
1125                      break;
1126                   case 65:
1127                      if ((0x400000004000L & l) != 0L)
1128                         jjstateSet[jjnewStateCnt++] = 64;
1129                      break;
1130                   case 66:
1131                      if ((0x20000000200L & l) != 0L)
1132                         jjstateSet[jjnewStateCnt++] = 65;
1133                      break;
1134                   case 68:
1135                      if ((0x2000000020L & l) != 0L)
1136                         jjstateSet[jjnewStateCnt++] = 67;
1137                      break;
1138                   case 69:
1139                      if ((0x4000000040000L & l) != 0L)
1140                         jjstateSet[jjnewStateCnt++] = 68;
1141                      break;
1142                   case 70:
1143                      if ((0x20000000200000L & l) != 0L)
1144                         jjstateSet[jjnewStateCnt++] = 69;
1145                      break;
1146                   case 71:
1147                      if ((0x10000000100000L & l) != 0L)
1148                         jjstateSet[jjnewStateCnt++] = 70;
1149                      break;
1150                   case 72:
1151                      if ((0x200000002L & l) != 0L)
1152                         jjstateSet[jjnewStateCnt++] = 71;
1153                      break;
1154                   case 73:
1155                      if ((0x2000000020L & l) != 0L)
1156                         jjstateSet[jjnewStateCnt++] = 72;
1157                      break;
1158                   case 74:
1159                      if ((0x4000000040L & l) != 0L)
1160                         jjstateSet[jjnewStateCnt++] = 73;
1161                      break;
1162                   case 76:
1163                      if ((0x80000000800L & l) != 0L)
1164                         jjstateSet[jjnewStateCnt++] = 77;
1165                      break;
1166                   case 78:
1167                      if ((0x800000008L & l) != 0L)
1168                         jjstateSet[jjnewStateCnt++] = 76;
1169                      break;
1170                   case 79:
1171                      if ((0x200000002L & l) != 0L)
1172                         jjstateSet[jjnewStateCnt++] = 78;
1173                      break;
1174                   case 80:
1175                      if ((0x4000000040000L & l) != 0L)
1176                         jjstateSet[jjnewStateCnt++] = 79;
1177                      break;
1178                   case 81:
1179                      if ((0x10000000100000L & l) != 0L)
1180                         jjstateSet[jjnewStateCnt++] = 80;
1181                      break;
1182                   case 83:
1183                      if ((0x400000004000L & l) != 0L)
1184                         jjstateSet[jjnewStateCnt++] = 82;
1185                      break;
1186                   case 84:
1187                      if ((0x20000000200L & l) != 0L)
1188                         jjstateSet[jjnewStateCnt++] = 83;
1189                      break;
1190                   case 86:
1191                      if ((0x2000000020L & l) != 0L)
1192                         jjstateSet[jjnewStateCnt++] = 85;
1193                      break;
1194                   case 87:
1195                      if ((0x4000000040000L & l) != 0L)
1196                         jjstateSet[jjnewStateCnt++] = 86;
1197                      break;
1198                   case 88:
1199                      if ((0x20000000200000L & l) != 0L)
1200                         jjstateSet[jjnewStateCnt++] = 87;
1201                      break;
1202                   case 89:
1203                      if ((0x10000000100000L & l) != 0L)
1204                         jjstateSet[jjnewStateCnt++] = 88;
1205                      break;
1206                   case 90:
1207                      if ((0x200000002L & l) != 0L)
1208                         jjstateSet[jjnewStateCnt++] = 89;
1209                      break;
1210                   case 91:
1211                      if ((0x2000000020L & l) != 0L)
1212                         jjstateSet[jjnewStateCnt++] = 90;
1213                      break;
1214                   case 92:
1215                      if ((0x4000000040L & l) != 0L)
1216                         jjstateSet[jjnewStateCnt++] = 91;
1217                      break;
1218                   case 94:
1219                      if ((0x7fffffe87fffffeL & l) == 0L)
1220                         break;
1221                      if (kind > 43)
1222                         kind = 43;
1223                      jjCheckNAddStates(3, 6);
1224                      break;
1225                   case 95:
1226                      if ((0x7fffffe87fffffeL & l) == 0L)
1227                         break;
1228                      if (kind > 43)
1229                         kind = 43;
1230                      jjCheckNAdd(95);
1231                      break;
1232                   case 96:
1233                      if ((0x7fffffe87fffffeL & l) != 0L)
1234                         jjCheckNAddStates(0, 2);
1235                      break;
1236                   default : break;
1237                }
1238             } while(i != startsAt);
1239          }
1240          else
1241          {
1242             int i2 = (curChar & 0xff) >> 6;
1243             long l2 = 1L << (curChar & 077);
1244             MatchLoop: do
1245             {
1246                switch(jjstateSet[--i])
1247                {
1248                   default : break;
1249                }
1250             } while(i != startsAt);
1251          }
1252          if (kind != 0x7fffffff)
1253          {
1254             jjmatchedKind = kind;
1255             jjmatchedPos = curPos;
1256             kind = 0x7fffffff;
1257          }
1258          ++curPos;
1259          if ((i = jjnewStateCnt) == (startsAt = 99 - (jjnewStateCnt = startsAt)))
1260             return curPos;
1261          try { curChar = input_stream.readChar(); }
1262          catch(java.io.IOException e) { return curPos; }
1263       }
1264    }
1265    static final int[] jjnextStates = {
1266       96, 97, 98, 95, 96, 97, 98, 75, 93, 45, 53, 30, 42, 22, 26, 
1267    };
1268    public static final String[] jjstrLiteralImages = {
1269    "", null, null, null, null, null, null, null, "\75", "\54", null, null, "\74", 
1270    null, "\76", null, null, "\173", "\175", "\50", "\51", "\133", "\135", "\176", null, 
1271    null, null, null, null, null, "\46\46", "\174\174", "\55", "\41", "\77", "\53", 
1272    "\52", "\12", null, null, null, null, null, null, null, null, null, "\73", };
1273    public static final String[] lexStateNames = {
1274       "DEFAULT", 
1275    };
1276    static final long[] jjtoToken = {
1277       0xffffffffff01L, 
1278    };
1279    static final long[] jjtoSkip = {
1280       0x3eL, 
1281    };
1282    protected SimpleCharStream input_stream;
1283    private final int[] jjrounds = new int[99];
1284    private final int[] jjstateSet = new int[198];
1285    protected char curChar;
1286    public ParserTokenManager(SimpleCharStream stream)
1287    {
1288       if (SimpleCharStream.staticFlag)
1289          throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1290       input_stream = stream;
1291    }
1292    public ParserTokenManager(SimpleCharStream stream, int lexState)
1293    {
1294       this(stream);
1295       SwitchTo(lexState);
1296    }
1297    public void ReInit(SimpleCharStream stream)
1298    {
1299       jjmatchedPos = jjnewStateCnt = 0;
1300       curLexState = defaultLexState;
1301       input_stream = stream;
1302       ReInitRounds();
1303    }
1304    private final void ReInitRounds()
1305    {
1306       int i;
1307       jjround = 0x80000001;
1308       for (i = 99; i-- > 0;)
1309          jjrounds[i] = 0x80000000;
1310    }
1311    public void ReInit(SimpleCharStream stream, int lexState)
1312    {
1313       ReInit(stream);
1314       SwitchTo(lexState);
1315    }
1316    public void SwitchTo(int lexState)
1317    {
1318       if (lexState >= 1 || lexState < 0)
1319          throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1320       else
1321          curLexState = lexState;
1322    }
1323    
1324    protected Token jjFillToken()
1325    {
1326       Token t = Token.newToken(jjmatchedKind);
1327       t.kind = jjmatchedKind;
1328       String im = jjstrLiteralImages[jjmatchedKind];
1329       t.image = (im == null) ? input_stream.GetImage() : im;
1330       t.beginLine = input_stream.getBeginLine();
1331       t.beginColumn = input_stream.getBeginColumn();
1332       t.endLine = input_stream.getEndLine();
1333       t.endColumn = input_stream.getEndColumn();
1334       return t;
1335    }
1336    
1337    int curLexState = 0;
1338    int defaultLexState = 0;
1339    int jjnewStateCnt;
1340    int jjround;
1341    int jjmatchedPos;
1342    int jjmatchedKind;
1343    
1344    public Token getNextToken() 
1345    {
1346      int kind;
1347      Token specialToken = null;
1348      Token matchedToken;
1349      int curPos = 0;
1350    
1351      EOFLoop :
1352      for (;;)
1353      {   
1354       try   
1355       {     
1356          curChar = input_stream.BeginToken();
1357       }     
1358       catch(java.io.IOException e)
1359       {        
1360          jjmatchedKind = 0;
1361          matchedToken = jjFillToken();
1362          return matchedToken;
1363       }
1364    
1365       try { input_stream.backup(0);
1366          while (curChar <= 32 && (0x100002200L & (1L << curChar)) != 0L)
1367             curChar = input_stream.BeginToken();
1368       }
1369       catch (java.io.IOException e1) { continue EOFLoop; }
1370       jjmatchedKind = 0x7fffffff;
1371       jjmatchedPos = 0;
1372       curPos = jjMoveStringLiteralDfa0_0();
1373       if (jjmatchedKind != 0x7fffffff)
1374       {
1375          if (jjmatchedPos + 1 < curPos)
1376             input_stream.backup(curPos - jjmatchedPos - 1);
1377          if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1378          {
1379             matchedToken = jjFillToken();
1380             return matchedToken;
1381          }
1382          else
1383          {
1384             continue EOFLoop;
1385          }
1386       }
1387       int error_line = input_stream.getEndLine();
1388       int error_column = input_stream.getEndColumn();
1389       String error_after = null;
1390       boolean EOFSeen = false;
1391       try { input_stream.readChar(); input_stream.backup(1); }
1392       catch (java.io.IOException e1) {
1393          EOFSeen = true;
1394          error_after = curPos <= 1 ? "" : input_stream.GetImage();
1395          if (curChar == '\n' || curChar == '\r') {
1396             error_line++;
1397             error_column = 0;
1398          }
1399          else
1400             error_column++;
1401       }
1402       if (!EOFSeen) {
1403          input_stream.backup(1);
1404          error_after = curPos <= 1 ? "" : input_stream.GetImage();
1405       }
1406       throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1407      }
1408    }
1409    
1410    }