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