View Javadoc

1   /* Generated By:JJTree&JavaCC: Do not edit this line. ExpressionParserTokenManager.java */
2   /***************************************************************************************
3    * Copyright (c) Jonas BonŽr, Alexandre Vasseur. All rights reserved.                 *
4    * http://aspectwerkz.codehaus.org                                                    *
5    * ---------------------------------------------------------------------------------- *
6    * The software in this package is published under the terms of the LGPL license      *
7    * a copy of which has been included with this distribution in the license.txt file.  *
8    **************************************************************************************/
9   package org.codehaus.aspectwerkz.expression.ast;
10  import java.lang.reflect.Modifier;
11  import java.io.Reader;
12  import java.io.StringReader;
13  
14  public class ExpressionParserTokenManager implements ExpressionParserConstants
15  {
16    public static  java.io.PrintStream debugStream = System.out;
17    public static  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
18  private static final int jjStopStringLiteralDfa_5(int pos, long active0, long active1)
19  {
20     switch (pos)
21     {
22        case 0:
23           if ((active0 & 0x7dff800L) != 0L)
24           {
25              jjmatchedKind = 28;
26              return 22;
27           }
28           if ((active0 & 0x10L) != 0L)
29              return 1;
30           if ((active0 & 0x200000L) != 0L)
31           {
32              jjmatchedKind = 28;
33              return 5;
34           }
35           return -1;
36        case 1:
37           if ((active0 & 0x7fff800L) != 0L)
38           {
39              jjmatchedKind = 28;
40              jjmatchedPos = 1;
41              return 22;
42           }
43           return -1;
44        case 2:
45           if ((active0 & 0x6fff800L) != 0L)
46           {
47              jjmatchedKind = 28;
48              jjmatchedPos = 2;
49              return 22;
50           }
51           return -1;
52        case 3:
53           if ((active0 & 0x6ff9800L) != 0L)
54           {
55              jjmatchedKind = 28;
56              jjmatchedPos = 3;
57              return 22;
58           }
59           return -1;
60        case 4:
61           if ((active0 & 0x65f8800L) != 0L)
62           {
63              jjmatchedKind = 28;
64              jjmatchedPos = 4;
65              return 22;
66           }
67           return -1;
68        case 5:
69           if ((active0 & 0x6578800L) != 0L)
70           {
71              jjmatchedKind = 28;
72              jjmatchedPos = 5;
73              return 22;
74           }
75           return -1;
76        case 6:
77           if ((active0 & 0x6168800L) != 0L)
78           {
79              jjmatchedKind = 28;
80              jjmatchedPos = 6;
81              return 22;
82           }
83           return -1;
84        case 7:
85           if ((active0 & 0x6160800L) != 0L)
86           {
87              jjmatchedKind = 28;
88              jjmatchedPos = 7;
89              return 22;
90           }
91           return -1;
92        case 8:
93           if ((active0 & 0x2160800L) != 0L)
94           {
95              jjmatchedKind = 28;
96              jjmatchedPos = 8;
97              return 22;
98           }
99           return -1;
100       case 9:
101          if ((active0 & 0x160000L) != 0L)
102          {
103             jjmatchedKind = 28;
104             jjmatchedPos = 9;
105             return 22;
106          }
107          return -1;
108       case 10:
109          if ((active0 & 0x40000L) != 0L)
110          {
111             jjmatchedKind = 28;
112             jjmatchedPos = 10;
113             return 22;
114          }
115          return -1;
116       case 11:
117          if ((active0 & 0x40000L) != 0L)
118          {
119             jjmatchedKind = 28;
120             jjmatchedPos = 11;
121             return 22;
122          }
123          return -1;
124       case 12:
125          if ((active0 & 0x40000L) != 0L)
126          {
127             jjmatchedKind = 28;
128             jjmatchedPos = 12;
129             return 22;
130          }
131          return -1;
132       case 13:
133          if ((active0 & 0x40000L) != 0L)
134          {
135             jjmatchedKind = 28;
136             jjmatchedPos = 13;
137             return 22;
138          }
139          return -1;
140       case 14:
141          if ((active0 & 0x40000L) != 0L)
142          {
143             jjmatchedKind = 28;
144             jjmatchedPos = 14;
145             return 22;
146          }
147          return -1;
148       case 15:
149          if ((active0 & 0x40000L) != 0L)
150          {
151             jjmatchedKind = 28;
152             jjmatchedPos = 15;
153             return 22;
154          }
155          return -1;
156       case 16:
157          if ((active0 & 0x40000L) != 0L)
158          {
159             jjmatchedKind = 28;
160             jjmatchedPos = 16;
161             return 22;
162          }
163          return -1;
164       case 17:
165          if ((active0 & 0x40000L) != 0L)
166          {
167             jjmatchedKind = 28;
168             jjmatchedPos = 17;
169             return 22;
170          }
171          return -1;
172       case 18:
173          if ((active0 & 0x40000L) != 0L)
174          {
175             jjmatchedKind = 28;
176             jjmatchedPos = 18;
177             return 22;
178          }
179          return -1;
180       case 19:
181          if ((active0 & 0x40000L) != 0L)
182          {
183             jjmatchedKind = 28;
184             jjmatchedPos = 19;
185             return 22;
186          }
187          return -1;
188       default :
189          return -1;
190    }
191 }
192 private static final int jjStartNfa_5(int pos, long active0, long active1)
193 {
194    return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1), pos + 1);
195 }
196 static private final int jjStopAtPos(int pos, int kind)
197 {
198    jjmatchedKind = kind;
199    jjmatchedPos = pos;
200    return pos + 1;
201 }
202 static private final int jjStartNfaWithStates_5(int pos, int kind, int state)
203 {
204    jjmatchedKind = kind;
205    jjmatchedPos = pos;
206    try { curChar = input_stream.readChar(); }
207    catch(java.io.IOException e) { return pos + 1; }
208    return jjMoveNfa_5(state, pos + 1);
209 }
210 static private final int jjMoveStringLiteralDfa0_5()
211 {
212    switch(curChar)
213    {
214       case 33:
215          return jjStopAtPos(0, 10);
216       case 40:
217          return jjStopAtPos(0, 86);
218       case 41:
219          return jjStopAtPos(0, 87);
220       case 44:
221          return jjStopAtPos(0, 3);
222       case 46:
223          return jjStartNfaWithStates_5(0, 4, 1);
224       case 97:
225          return jjMoveStringLiteralDfa1_5(0x200000L);
226       case 99:
227          return jjMoveStringLiteralDfa1_5(0x181000L);
228       case 101:
229          return jjMoveStringLiteralDfa1_5(0x800L);
230       case 103:
231          return jjMoveStringLiteralDfa1_5(0x4000L);
232       case 104:
233          return jjMoveStringLiteralDfa1_5(0x6008000L);
234       case 105:
235          return jjMoveStringLiteralDfa1_5(0x1000000L);
236       case 115:
237          return jjMoveStringLiteralDfa1_5(0x42000L);
238       case 116:
239          return jjMoveStringLiteralDfa1_5(0xc00000L);
240       case 119:
241          return jjMoveStringLiteralDfa1_5(0x30000L);
242       default :
243          return jjMoveNfa_5(0, 0);
244    }
245 }
246 static private final int jjMoveStringLiteralDfa1_5(long active0)
247 {
248    try { curChar = input_stream.readChar(); }
249    catch(java.io.IOException e) {
250       jjStopStringLiteralDfa_5(0, active0, 0L);
251       return 1;
252    }
253    switch(curChar)
254    {
255       case 97:
256          return jjMoveStringLiteralDfa2_5(active0, 0x6409000L);
257       case 101:
258          return jjMoveStringLiteralDfa2_5(active0, 0x6000L);
259       case 102:
260          return jjMoveStringLiteralDfa2_5(active0, 0x1180000L);
261       case 104:
262          return jjMoveStringLiteralDfa2_5(active0, 0x800000L);
263       case 105:
264          return jjMoveStringLiteralDfa2_5(active0, 0x30000L);
265       case 114:
266          return jjMoveStringLiteralDfa2_5(active0, 0x200000L);
267       case 116:
268          return jjMoveStringLiteralDfa2_5(active0, 0x40000L);
269       case 120:
270          return jjMoveStringLiteralDfa2_5(active0, 0x800L);
271       default :
272          break;
273    }
274    return jjStartNfa_5(0, active0, 0L);
275 }
276 static private final int jjMoveStringLiteralDfa2_5(long old0, long active0)
277 {
278    if (((active0 &= old0)) == 0L)
279       return jjStartNfa_5(0, old0, 0L);
280    try { curChar = input_stream.readChar(); }
281    catch(java.io.IOException e) {
282       jjStopStringLiteralDfa_5(1, active0, 0L);
283       return 2;
284    }
285    switch(curChar)
286    {
287       case 40:
288          if ((active0 & 0x1000000L) != 0L)
289             return jjStopAtPos(2, 24);
290          break;
291       case 97:
292          return jjMoveStringLiteralDfa3_5(active0, 0x40000L);
293       case 101:
294          return jjMoveStringLiteralDfa3_5(active0, 0x800L);
295       case 103:
296          return jjMoveStringLiteralDfa3_5(active0, 0x200000L);
297       case 105:
298          return jjMoveStringLiteralDfa3_5(active0, 0x800000L);
299       case 108:
300          return jjMoveStringLiteralDfa3_5(active0, 0x181000L);
301       case 110:
302          return jjMoveStringLiteralDfa3_5(active0, 0x8000L);
303       case 114:
304          return jjMoveStringLiteralDfa3_5(active0, 0x400000L);
305       case 115:
306          return jjMoveStringLiteralDfa3_5(active0, 0x6000000L);
307       case 116:
308          return jjMoveStringLiteralDfa3_5(active0, 0x36000L);
309       default :
310          break;
311    }
312    return jjStartNfa_5(1, active0, 0L);
313 }
314 static private final int jjMoveStringLiteralDfa3_5(long old0, long active0)
315 {
316    if (((active0 &= old0)) == 0L)
317       return jjStartNfa_5(1, old0, 0L);
318    try { curChar = input_stream.readChar(); }
319    catch(java.io.IOException e) {
320       jjStopStringLiteralDfa_5(2, active0, 0L);
321       return 3;
322    }
323    switch(curChar)
324    {
325       case 40:
326          if ((active0 & 0x2000L) != 0L)
327             return jjStopAtPos(3, 13);
328          else if ((active0 & 0x4000L) != 0L)
329             return jjStopAtPos(3, 14);
330          break;
331       case 99:
332          return jjMoveStringLiteralDfa4_5(active0, 0x800L);
333       case 100:
334          return jjMoveStringLiteralDfa4_5(active0, 0x8000L);
335       case 102:
336          return jjMoveStringLiteralDfa4_5(active0, 0x4000000L);
337       case 103:
338          return jjMoveStringLiteralDfa4_5(active0, 0x400000L);
339       case 104:
340          return jjMoveStringLiteralDfa4_5(active0, 0x30000L);
341       case 108:
342          return jjMoveStringLiteralDfa4_5(active0, 0x1000L);
343       case 109:
344          return jjMoveStringLiteralDfa4_5(active0, 0x2000000L);
345       case 111:
346          return jjMoveStringLiteralDfa4_5(active0, 0x180000L);
347       case 115:
348          return jjMoveStringLiteralDfa4_5(active0, 0xa00000L);
349       case 116:
350          return jjMoveStringLiteralDfa4_5(active0, 0x40000L);
351       default :
352          break;
353    }
354    return jjStartNfa_5(2, active0, 0L);
355 }
356 static private final int jjMoveStringLiteralDfa4_5(long old0, long active0)
357 {
358    if (((active0 &= old0)) == 0L)
359       return jjStartNfa_5(2, old0, 0L);
360    try { curChar = input_stream.readChar(); }
361    catch(java.io.IOException e) {
362       jjStopStringLiteralDfa_5(3, active0, 0L);
363       return 4;
364    }
365    switch(curChar)
366    {
367       case 40:
368          if ((active0 & 0x1000L) != 0L)
369             return jjStopAtPos(4, 12);
370          else if ((active0 & 0x200000L) != 0L)
371             return jjStopAtPos(4, 21);
372          else if ((active0 & 0x800000L) != 0L)
373             return jjStopAtPos(4, 23);
374          break;
375       case 101:
376          return jjMoveStringLiteralDfa5_5(active0, 0x2400000L);
377       case 105:
378          return jjMoveStringLiteralDfa5_5(active0, 0x4070000L);
379       case 108:
380          return jjMoveStringLiteralDfa5_5(active0, 0x8000L);
381       case 117:
382          return jjMoveStringLiteralDfa5_5(active0, 0x800L);
383       case 119:
384          return jjMoveStringLiteralDfa5_5(active0, 0x180000L);
385       default :
386          break;
387    }
388    return jjStartNfa_5(3, active0, 0L);
389 }
390 static private final int jjMoveStringLiteralDfa5_5(long old0, long active0)
391 {
392    if (((active0 &= old0)) == 0L)
393       return jjStartNfa_5(3, old0, 0L);
394    try { curChar = input_stream.readChar(); }
395    catch(java.io.IOException e) {
396       jjStopStringLiteralDfa_5(4, active0, 0L);
397       return 5;
398    }
399    switch(curChar)
400    {
401       case 40:
402          if ((active0 & 0x80000L) != 0L)
403             return jjStopAtPos(5, 19);
404          break;
405       case 98:
406          return jjMoveStringLiteralDfa6_5(active0, 0x100000L);
407       case 99:
408          return jjMoveStringLiteralDfa6_5(active0, 0x40000L);
409       case 101:
410          return jjMoveStringLiteralDfa6_5(active0, 0x4008000L);
411       case 110:
412          return jjMoveStringLiteralDfa6_5(active0, 0x30000L);
413       case 116:
414          return jjMoveStringLiteralDfa6_5(active0, 0x2400800L);
415       default :
416          break;
417    }
418    return jjStartNfa_5(4, active0, 0L);
419 }
420 static private final int jjMoveStringLiteralDfa6_5(long old0, long active0)
421 {
422    if (((active0 &= old0)) == 0L)
423       return jjStartNfa_5(4, old0, 0L);
424    try { curChar = input_stream.readChar(); }
425    catch(java.io.IOException e) {
426       jjStopStringLiteralDfa_5(5, active0, 0L);
427       return 6;
428    }
429    switch(curChar)
430    {
431       case 40:
432          if ((active0 & 0x10000L) != 0L)
433             return jjStopAtPos(6, 16);
434          else if ((active0 & 0x400000L) != 0L)
435             return jjStopAtPos(6, 22);
436          break;
437       case 99:
438          return jjMoveStringLiteralDfa7_5(active0, 0x20000L);
439       case 101:
440          return jjMoveStringLiteralDfa7_5(active0, 0x100000L);
441       case 104:
442          return jjMoveStringLiteralDfa7_5(active0, 0x2000000L);
443       case 105:
444          return jjMoveStringLiteralDfa7_5(active0, 0x40800L);
445       case 108:
446          return jjMoveStringLiteralDfa7_5(active0, 0x4000000L);
447       case 114:
448          return jjMoveStringLiteralDfa7_5(active0, 0x8000L);
449       default :
450          break;
451    }
452    return jjStartNfa_5(5, active0, 0L);
453 }
454 static private final int jjMoveStringLiteralDfa7_5(long old0, long active0)
455 {
456    if (((active0 &= old0)) == 0L)
457       return jjStartNfa_5(5, old0, 0L);
458    try { curChar = input_stream.readChar(); }
459    catch(java.io.IOException e) {
460       jjStopStringLiteralDfa_5(6, active0, 0L);
461       return 7;
462    }
463    switch(curChar)
464    {
465       case 40:
466          if ((active0 & 0x8000L) != 0L)
467             return jjStopAtPos(7, 15);
468          break;
469       case 100:
470          return jjMoveStringLiteralDfa8_5(active0, 0x4000000L);
471       case 108:
472          return jjMoveStringLiteralDfa8_5(active0, 0x100000L);
473       case 110:
474          return jjMoveStringLiteralDfa8_5(active0, 0x40000L);
475       case 111:
476          return jjMoveStringLiteralDfa8_5(active0, 0x2020800L);
477       default :
478          break;
479    }
480    return jjStartNfa_5(6, active0, 0L);
481 }
482 static private final int jjMoveStringLiteralDfa8_5(long old0, long active0)
483 {
484    if (((active0 &= old0)) == 0L)
485       return jjStartNfa_5(6, old0, 0L);
486    try { curChar = input_stream.readChar(); }
487    catch(java.io.IOException e) {
488       jjStopStringLiteralDfa_5(7, active0, 0L);
489       return 8;
490    }
491    switch(curChar)
492    {
493       case 40:
494          if ((active0 & 0x4000000L) != 0L)
495             return jjStopAtPos(8, 26);
496          break;
497       case 100:
498          return jjMoveStringLiteralDfa9_5(active0, 0x2020000L);
499       case 105:
500          return jjMoveStringLiteralDfa9_5(active0, 0x40000L);
501       case 110:
502          return jjMoveStringLiteralDfa9_5(active0, 0x800L);
503       case 111:
504          return jjMoveStringLiteralDfa9_5(active0, 0x100000L);
505       default :
506          break;
507    }
508    return jjStartNfa_5(7, active0, 0L);
509 }
510 static private final int jjMoveStringLiteralDfa9_5(long old0, long active0)
511 {
512    if (((active0 &= old0)) == 0L)
513       return jjStartNfa_5(7, old0, 0L);
514    try { curChar = input_stream.readChar(); }
515    catch(java.io.IOException e) {
516       jjStopStringLiteralDfa_5(8, active0, 0L);
517       return 9;
518    }
519    switch(curChar)
520    {
521       case 40:
522          if ((active0 & 0x800L) != 0L)
523             return jjStopAtPos(9, 11);
524          else if ((active0 & 0x2000000L) != 0L)
525             return jjStopAtPos(9, 25);
526          break;
527       case 101:
528          return jjMoveStringLiteralDfa10_5(active0, 0x20000L);
529       case 116:
530          return jjMoveStringLiteralDfa10_5(active0, 0x40000L);
531       case 119:
532          return jjMoveStringLiteralDfa10_5(active0, 0x100000L);
533       default :
534          break;
535    }
536    return jjStartNfa_5(8, active0, 0L);
537 }
538 static private final int jjMoveStringLiteralDfa10_5(long old0, long active0)
539 {
540    if (((active0 &= old0)) == 0L)
541       return jjStartNfa_5(8, old0, 0L);
542    try { curChar = input_stream.readChar(); }
543    catch(java.io.IOException e) {
544       jjStopStringLiteralDfa_5(9, active0, 0L);
545       return 10;
546    }
547    switch(curChar)
548    {
549       case 40:
550          if ((active0 & 0x20000L) != 0L)
551             return jjStopAtPos(10, 17);
552          else if ((active0 & 0x100000L) != 0L)
553             return jjStopAtPos(10, 20);
554          break;
555       case 105:
556          return jjMoveStringLiteralDfa11_5(active0, 0x40000L);
557       default :
558          break;
559    }
560    return jjStartNfa_5(9, active0, 0L);
561 }
562 static private final int jjMoveStringLiteralDfa11_5(long old0, long active0)
563 {
564    if (((active0 &= old0)) == 0L)
565       return jjStartNfa_5(9, old0, 0L);
566    try { curChar = input_stream.readChar(); }
567    catch(java.io.IOException e) {
568       jjStopStringLiteralDfa_5(10, active0, 0L);
569       return 11;
570    }
571    switch(curChar)
572    {
573       case 97:
574          return jjMoveStringLiteralDfa12_5(active0, 0x40000L);
575       default :
576          break;
577    }
578    return jjStartNfa_5(10, active0, 0L);
579 }
580 static private final int jjMoveStringLiteralDfa12_5(long old0, long active0)
581 {
582    if (((active0 &= old0)) == 0L)
583       return jjStartNfa_5(10, old0, 0L);
584    try { curChar = input_stream.readChar(); }
585    catch(java.io.IOException e) {
586       jjStopStringLiteralDfa_5(11, active0, 0L);
587       return 12;
588    }
589    switch(curChar)
590    {
591       case 108:
592          return jjMoveStringLiteralDfa13_5(active0, 0x40000L);
593       default :
594          break;
595    }
596    return jjStartNfa_5(11, active0, 0L);
597 }
598 static private final int jjMoveStringLiteralDfa13_5(long old0, long active0)
599 {
600    if (((active0 &= old0)) == 0L)
601       return jjStartNfa_5(11, old0, 0L);
602    try { curChar = input_stream.readChar(); }
603    catch(java.io.IOException e) {
604       jjStopStringLiteralDfa_5(12, active0, 0L);
605       return 13;
606    }
607    switch(curChar)
608    {
609       case 105:
610          return jjMoveStringLiteralDfa14_5(active0, 0x40000L);
611       default :
612          break;
613    }
614    return jjStartNfa_5(12, active0, 0L);
615 }
616 static private final int jjMoveStringLiteralDfa14_5(long old0, long active0)
617 {
618    if (((active0 &= old0)) == 0L)
619       return jjStartNfa_5(12, old0, 0L);
620    try { curChar = input_stream.readChar(); }
621    catch(java.io.IOException e) {
622       jjStopStringLiteralDfa_5(13, active0, 0L);
623       return 14;
624    }
625    switch(curChar)
626    {
627       case 122:
628          return jjMoveStringLiteralDfa15_5(active0, 0x40000L);
629       default :
630          break;
631    }
632    return jjStartNfa_5(13, active0, 0L);
633 }
634 static private final int jjMoveStringLiteralDfa15_5(long old0, long active0)
635 {
636    if (((active0 &= old0)) == 0L)
637       return jjStartNfa_5(13, old0, 0L);
638    try { curChar = input_stream.readChar(); }
639    catch(java.io.IOException e) {
640       jjStopStringLiteralDfa_5(14, active0, 0L);
641       return 15;
642    }
643    switch(curChar)
644    {
645       case 97:
646          return jjMoveStringLiteralDfa16_5(active0, 0x40000L);
647       default :
648          break;
649    }
650    return jjStartNfa_5(14, active0, 0L);
651 }
652 static private final int jjMoveStringLiteralDfa16_5(long old0, long active0)
653 {
654    if (((active0 &= old0)) == 0L)
655       return jjStartNfa_5(14, old0, 0L);
656    try { curChar = input_stream.readChar(); }
657    catch(java.io.IOException e) {
658       jjStopStringLiteralDfa_5(15, active0, 0L);
659       return 16;
660    }
661    switch(curChar)
662    {
663       case 116:
664          return jjMoveStringLiteralDfa17_5(active0, 0x40000L);
665       default :
666          break;
667    }
668    return jjStartNfa_5(15, active0, 0L);
669 }
670 static private final int jjMoveStringLiteralDfa17_5(long old0, long active0)
671 {
672    if (((active0 &= old0)) == 0L)
673       return jjStartNfa_5(15, old0, 0L);
674    try { curChar = input_stream.readChar(); }
675    catch(java.io.IOException e) {
676       jjStopStringLiteralDfa_5(16, active0, 0L);
677       return 17;
678    }
679    switch(curChar)
680    {
681       case 105:
682          return jjMoveStringLiteralDfa18_5(active0, 0x40000L);
683       default :
684          break;
685    }
686    return jjStartNfa_5(16, active0, 0L);
687 }
688 static private final int jjMoveStringLiteralDfa18_5(long old0, long active0)
689 {
690    if (((active0 &= old0)) == 0L)
691       return jjStartNfa_5(16, old0, 0L);
692    try { curChar = input_stream.readChar(); }
693    catch(java.io.IOException e) {
694       jjStopStringLiteralDfa_5(17, active0, 0L);
695       return 18;
696    }
697    switch(curChar)
698    {
699       case 111:
700          return jjMoveStringLiteralDfa19_5(active0, 0x40000L);
701       default :
702          break;
703    }
704    return jjStartNfa_5(17, active0, 0L);
705 }
706 static private final int jjMoveStringLiteralDfa19_5(long old0, long active0)
707 {
708    if (((active0 &= old0)) == 0L)
709       return jjStartNfa_5(17, old0, 0L);
710    try { curChar = input_stream.readChar(); }
711    catch(java.io.IOException e) {
712       jjStopStringLiteralDfa_5(18, active0, 0L);
713       return 19;
714    }
715    switch(curChar)
716    {
717       case 110:
718          return jjMoveStringLiteralDfa20_5(active0, 0x40000L);
719       default :
720          break;
721    }
722    return jjStartNfa_5(18, active0, 0L);
723 }
724 static private final int jjMoveStringLiteralDfa20_5(long old0, long active0)
725 {
726    if (((active0 &= old0)) == 0L)
727       return jjStartNfa_5(18, old0, 0L);
728    try { curChar = input_stream.readChar(); }
729    catch(java.io.IOException e) {
730       jjStopStringLiteralDfa_5(19, active0, 0L);
731       return 20;
732    }
733    switch(curChar)
734    {
735       case 40:
736          if ((active0 & 0x40000L) != 0L)
737             return jjStopAtPos(20, 18);
738          break;
739       default :
740          break;
741    }
742    return jjStartNfa_5(19, active0, 0L);
743 }
744 static private final void jjCheckNAdd(int state)
745 {
746    if (jjrounds[state] != jjround)
747    {
748       jjstateSet[jjnewStateCnt++] = state;
749       jjrounds[state] = jjround;
750    }
751 }
752 static private final void jjAddStates(int start, int end)
753 {
754    do {
755       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
756    } while (start++ != end);
757 }
758 static private final void jjCheckNAddTwoStates(int state1, int state2)
759 {
760    jjCheckNAdd(state1);
761    jjCheckNAdd(state2);
762 }
763 static private final void jjCheckNAddStates(int start, int end)
764 {
765    do {
766       jjCheckNAdd(jjnextStates[start]);
767    } while (start++ != end);
768 }
769 static private final void jjCheckNAddStates(int start)
770 {
771    jjCheckNAdd(jjnextStates[start]);
772    jjCheckNAdd(jjnextStates[start + 1]);
773 }
774 static private final int jjMoveNfa_5(int startState, int curPos)
775 {
776    int[] nextStates;
777    int startsAt = 0;
778    jjnewStateCnt = 22;
779    int i = 1;
780    jjstateSet[0] = startState;
781    int j, kind = 0x7fffffff;
782    for (;;)
783    {
784       if (++jjround == 0x7fffffff)
785          ReInitRounds();
786       if (curChar < 64)
787       {
788          long l = 1L << curChar;
789          MatchLoop: do
790          {
791             switch(jjstateSet[--i])
792             {
793                case 5:
794                   if ((0x3ff401000000000L & l) != 0L)
795                   {
796                      if (kind > 28)
797                         kind = 28;
798                      jjCheckNAdd(21);
799                   }
800                   else if (curChar == 40)
801                   {
802                      if (kind > 27)
803                         kind = 27;
804                   }
805                   if ((0x3ff401000000000L & l) != 0L)
806                      jjCheckNAddTwoStates(19, 20);
807                   break;
808                case 22:
809                   if ((0x3ff401000000000L & l) != 0L)
810                   {
811                      if (kind > 28)
812                         kind = 28;
813                      jjCheckNAdd(21);
814                   }
815                   else if (curChar == 40)
816                   {
817                      if (kind > 27)
818                         kind = 27;
819                   }
820                   if ((0x3ff401000000000L & l) != 0L)
821                      jjCheckNAddTwoStates(19, 20);
822                   break;
823                case 1:
824                   if ((0x3ff401000000000L & l) != 0L)
825                   {
826                      if (kind > 28)
827                         kind = 28;
828                      jjCheckNAdd(21);
829                   }
830                   else if (curChar == 40)
831                   {
832                      if (kind > 27)
833                         kind = 27;
834                   }
835                   if ((0x3ff401000000000L & l) != 0L)
836                      jjCheckNAddTwoStates(19, 20);
837                   if (curChar == 46)
838                   {
839                      if (kind > 7)
840                         kind = 7;
841                   }
842                   break;
843                case 0:
844                   if ((0x3ff401000000000L & l) != 0L)
845                   {
846                      if (kind > 28)
847                         kind = 28;
848                      jjCheckNAddStates(0, 2);
849                   }
850                   else if (curChar == 38)
851                   {
852                      if (kind > 8)
853                         kind = 8;
854                   }
855                   if (curChar == 38)
856                      jjstateSet[jjnewStateCnt++] = 2;
857                   else if (curChar == 46)
858                      jjstateSet[jjnewStateCnt++] = 1;
859                   break;
860                case 2:
861                   if (curChar == 38 && kind > 8)
862                      kind = 8;
863                   break;
864                case 3:
865                   if (curChar == 38)
866                      jjstateSet[jjnewStateCnt++] = 2;
867                   break;
868                case 10:
869                   if (curChar == 38 && kind > 8)
870                      kind = 8;
871                   break;
872                case 18:
873                   if ((0x3ff401000000000L & l) == 0L)
874                      break;
875                   if (kind > 28)
876                      kind = 28;
877                   jjCheckNAddStates(0, 2);
878                   break;
879                case 19:
880                   if ((0x3ff401000000000L & l) != 0L)
881                      jjCheckNAddTwoStates(19, 20);
882                   break;
883                case 20:
884                   if (curChar == 40)
885                      kind = 27;
886                   break;
887                case 21:
888                   if ((0x3ff401000000000L & l) == 0L)
889                      break;
890                   if (kind > 28)
891                      kind = 28;
892                   jjCheckNAdd(21);
893                   break;
894                default : break;
895             }
896          } while(i != startsAt);
897       }
898       else if (curChar < 128)
899       {
900          long l = 1L << (curChar & 077);
901          MatchLoop: do
902          {
903             switch(jjstateSet[--i])
904             {
905                case 5:
906                   if ((0x7fffffe87fffffeL & l) != 0L)
907                   {
908                      if (kind > 28)
909                         kind = 28;
910                      jjCheckNAdd(21);
911                   }
912                   if ((0x7fffffe87fffffeL & l) != 0L)
913                      jjCheckNAddTwoStates(19, 20);
914                   if (curChar == 110)
915                      jjstateSet[jjnewStateCnt++] = 4;
916                   break;
917                case 22:
918                   if ((0x7fffffe87fffffeL & l) != 0L)
919                   {
920                      if (kind > 28)
921                         kind = 28;
922                      jjCheckNAdd(21);
923                   }
924                   if ((0x7fffffe87fffffeL & l) != 0L)
925                      jjCheckNAddTwoStates(19, 20);
926                   break;
927                case 1:
928                   if ((0x7fffffe87fffffeL & l) != 0L)
929                   {
930                      if (kind > 28)
931                         kind = 28;
932                      jjCheckNAdd(21);
933                   }
934                   if ((0x7fffffe87fffffeL & l) != 0L)
935                      jjCheckNAddTwoStates(19, 20);
936                   break;
937                case 0:
938                   if ((0x7fffffe87fffffeL & l) != 0L)
939                   {
940                      if (kind > 28)
941                         kind = 28;
942                      jjCheckNAddStates(0, 2);
943                   }
944                   else if (curChar == 124)
945                   {
946                      if (kind > 9)
947                         kind = 9;
948                   }
949                   if (curChar == 79)
950                      jjstateSet[jjnewStateCnt++] = 15;
951                   else if (curChar == 111)
952                      jjstateSet[jjnewStateCnt++] = 13;
953                   else if (curChar == 124)
954                      jjstateSet[jjnewStateCnt++] = 11;
955                   else if (curChar == 65)
956                      jjstateSet[jjnewStateCnt++] = 8;
957                   else if (curChar == 97)
958                      jjstateSet[jjnewStateCnt++] = 5;
959                   break;
960                case 4:
961                   if (curChar == 100 && kind > 8)
962                      kind = 8;
963                   break;
964                case 6:
965                   if (curChar == 97)
966                      jjstateSet[jjnewStateCnt++] = 5;
967                   break;
968                case 7:
969                   if (curChar == 68 && kind > 8)
970                      kind = 8;
971                   break;
972                case 8:
973                   if (curChar == 78)
974                      jjstateSet[jjnewStateCnt++] = 7;
975                   break;
976                case 9:
977                   if (curChar == 65)
978                      jjstateSet[jjnewStateCnt++] = 8;
979                   break;
980                case 11:
981                   if (curChar == 124 && kind > 9)
982                      kind = 9;
983                   break;
984                case 12:
985                   if (curChar == 124)
986                      jjstateSet[jjnewStateCnt++] = 11;
987                   break;
988                case 13:
989                   if (curChar == 114 && kind > 9)
990                      kind = 9;
991                   break;
992                case 14:
993                   if (curChar == 111)
994                      jjstateSet[jjnewStateCnt++] = 13;
995                   break;
996                case 15:
997                   if (curChar == 82 && kind > 9)
998                      kind = 9;
999                   break;
1000                case 16:
1001                   if (curChar == 79)
1002                      jjstateSet[jjnewStateCnt++] = 15;
1003                   break;
1004                case 17:
1005                   if (curChar == 124 && kind > 9)
1006                      kind = 9;
1007                   break;
1008                case 18:
1009                   if ((0x7fffffe87fffffeL & l) == 0L)
1010                      break;
1011                   if (kind > 28)
1012                      kind = 28;
1013                   jjCheckNAddStates(0, 2);
1014                   break;
1015                case 19:
1016                   if ((0x7fffffe87fffffeL & l) != 0L)
1017                      jjCheckNAddTwoStates(19, 20);
1018                   break;
1019                case 21:
1020                   if ((0x7fffffe87fffffeL & l) == 0L)
1021                      break;
1022                   if (kind > 28)
1023                      kind = 28;
1024                   jjCheckNAdd(21);
1025                   break;
1026                default : break;
1027             }
1028          } while(i != startsAt);
1029       }
1030       else
1031       {
1032          int i2 = (curChar & 0xff) >> 6;
1033          long l2 = 1L << (curChar & 077);
1034          MatchLoop: do
1035          {
1036             switch(jjstateSet[--i])
1037             {
1038                default : break;
1039             }
1040          } while(i != startsAt);
1041       }
1042       if (kind != 0x7fffffff)
1043       {
1044          jjmatchedKind = kind;
1045          jjmatchedPos = curPos;
1046          kind = 0x7fffffff;
1047       }
1048       ++curPos;
1049       if ((i = jjnewStateCnt) == (startsAt = 22 - (jjnewStateCnt = startsAt)))
1050          return curPos;
1051       try { curChar = input_stream.readChar(); }
1052       catch(java.io.IOException e) { return curPos; }
1053    }
1054 }
1055 private static final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
1056 {
1057    switch (pos)
1058    {
1059       default :
1060          return -1;
1061    }
1062 }
1063 private static final int jjStartNfa_0(int pos, long active0, long active1)
1064 {
1065    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
1066 }
1067 static private final int jjStartNfaWithStates_0(int pos, int kind, int state)
1068 {
1069    jjmatchedKind = kind;
1070    jjmatchedPos = pos;
1071    try { curChar = input_stream.readChar(); }
1072    catch(java.io.IOException e) { return pos + 1; }
1073    return jjMoveNfa_0(state, pos + 1);
1074 }
1075 static private final int jjMoveStringLiteralDfa0_0()
1076 {
1077    switch(curChar)
1078    {
1079       case 41:
1080          return jjStopAtPos(0, 85);
1081       case 44:
1082          return jjStopAtPos(0, 3);
1083       case 46:
1084          return jjStartNfaWithStates_0(0, 4, 1);
1085       default :
1086          return jjMoveNfa_0(0, 0);
1087    }
1088 }
1089 static private final int jjMoveNfa_0(int startState, int curPos)
1090 {
1091    int[] nextStates;
1092    int startsAt = 0;
1093    jjnewStateCnt = 11;
1094    int i = 1;
1095    jjstateSet[0] = startState;
1096    int j, kind = 0x7fffffff;
1097    for (;;)
1098    {
1099       if (++jjround == 0x7fffffff)
1100          ReInitRounds();
1101       if (curChar < 64)
1102       {
1103          long l = 1L << curChar;
1104          MatchLoop: do
1105          {
1106             switch(jjstateSet[--i])
1107             {
1108                case 0:
1109                   if ((0x3ff081800000000L & l) != 0L)
1110                   {
1111                      if (kind > 82)
1112                         kind = 82;
1113                      jjCheckNAddStates(3, 7);
1114                   }
1115                   else if (curChar == 46)
1116                      jjstateSet[jjnewStateCnt++] = 1;
1117                   break;
1118                case 1:
1119                   if (curChar == 46 && kind > 7)
1120                      kind = 7;
1121                   break;
1122                case 2:
1123                   if ((0x3ff081800000000L & l) == 0L)
1124                      break;
1125                   if (kind > 82)
1126                      kind = 82;
1127                   jjCheckNAddStates(3, 7);
1128                   break;
1129                case 3:
1130                   if ((0x3ff081800000000L & l) == 0L)
1131                      break;
1132                   if (kind > 82)
1133                      kind = 82;
1134                   jjCheckNAddTwoStates(3, 4);
1135                   break;
1136                case 4:
1137                   if (curChar == 46)
1138                      jjCheckNAdd(5);
1139                   break;
1140                case 5:
1141                   if ((0x3ff081800000000L & l) == 0L)
1142                      break;
1143                   if (kind > 82)
1144                      kind = 82;
1145                   jjCheckNAddTwoStates(4, 5);
1146                   break;
1147                case 6:
1148                   if ((0x3ff081800000000L & l) == 0L)
1149                      break;
1150                   if (kind > 83)
1151                      kind = 83;
1152                   jjCheckNAddStates(8, 10);
1153                   break;
1154                case 7:
1155                   if (curChar == 46)
1156                      jjCheckNAdd(8);
1157                   break;
1158                case 8:
1159                   if ((0x3ff081800000000L & l) == 0L)
1160                      break;
1161                   if (kind > 83)
1162                      kind = 83;
1163                   jjCheckNAddStates(11, 13);
1164                   break;
1165                default : break;
1166             }
1167          } while(i != startsAt);
1168       }
1169       else if (curChar < 128)
1170       {
1171          long l = 1L << (curChar & 077);
1172          MatchLoop: do
1173          {
1174             switch(jjstateSet[--i])
1175             {
1176                case 0:
1177                   if ((0x7fffffe87fffffeL & l) == 0L)
1178                      break;
1179                   if (kind > 82)
1180                      kind = 82;
1181                   jjCheckNAddStates(3, 7);
1182                   break;
1183                case 3:
1184                   if ((0x7fffffe87fffffeL & l) == 0L)
1185                      break;
1186                   if (kind > 82)
1187                      kind = 82;
1188                   jjCheckNAddTwoStates(3, 4);
1189                   break;
1190                case 5:
1191                   if ((0x7fffffe87fffffeL & l) == 0L)
1192                      break;
1193                   if (kind > 82)
1194                      kind = 82;
1195                   jjCheckNAddTwoStates(4, 5);
1196                   break;
1197                case 6:
1198                   if ((0x7fffffe87fffffeL & l) == 0L)
1199                      break;
1200                   if (kind > 83)
1201                      kind = 83;
1202                   jjCheckNAddStates(8, 10);
1203                   break;
1204                case 8:
1205                   if ((0x7fffffe87fffffeL & l) == 0L)
1206                      break;
1207                   if (kind > 83)
1208                      kind = 83;
1209                   jjCheckNAddStates(11, 13);
1210                   break;
1211                case 9:
1212                   if (curChar != 93)
1213                      break;
1214                   kind = 83;
1215                   jjCheckNAdd(10);
1216                   break;
1217                case 10:
1218                   if (curChar == 91)
1219                      jjstateSet[jjnewStateCnt++] = 9;
1220                   break;
1221                default : break;
1222             }
1223          } while(i != startsAt);
1224       }
1225       else
1226       {
1227          int i2 = (curChar & 0xff) >> 6;
1228          long l2 = 1L << (curChar & 077);
1229          MatchLoop: do
1230          {
1231             switch(jjstateSet[--i])
1232             {
1233                default : break;
1234             }
1235          } while(i != startsAt);
1236       }
1237       if (kind != 0x7fffffff)
1238       {
1239          jjmatchedKind = kind;
1240          jjmatchedPos = curPos;
1241          kind = 0x7fffffff;
1242       }
1243       ++curPos;
1244       if ((i = jjnewStateCnt) == (startsAt = 11 - (jjnewStateCnt = startsAt)))
1245          return curPos;
1246       try { curChar = input_stream.readChar(); }
1247       catch(java.io.IOException e) { return curPos; }
1248    }
1249 }
1250 private static final int jjStopStringLiteralDfa_4(int pos, long active0)
1251 {
1252    switch (pos)
1253    {
1254       case 0:
1255          if ((active0 & 0x10L) != 0L)
1256             return 12;
1257          if ((active0 & 0x7e0000000L) != 0L)
1258          {
1259             jjmatchedKind = 37;
1260             return 13;
1261          }
1262          return -1;
1263       case 1:
1264          if ((active0 & 0x7e0000000L) != 0L)
1265          {
1266             jjmatchedKind = 37;
1267             jjmatchedPos = 1;
1268             return 13;
1269          }
1270          return -1;
1271       case 2:
1272          if ((active0 & 0x7e0000000L) != 0L)
1273          {
1274             jjmatchedKind = 37;
1275             jjmatchedPos = 2;
1276             return 13;
1277          }
1278          return -1;
1279       case 3:
1280          if ((active0 & 0x7e0000000L) != 0L)
1281          {
1282             jjmatchedKind = 37;
1283             jjmatchedPos = 3;
1284             return 13;
1285          }
1286          return -1;
1287       case 4:
1288          if ((active0 & 0x3e0000000L) != 0L)
1289          {
1290             jjmatchedKind = 37;
1291             jjmatchedPos = 4;
1292             return 13;
1293          }
1294          if ((active0 & 0x400000000L) != 0L)
1295             return 13;
1296          return -1;
1297       case 5:
1298          if ((active0 & 0x180000000L) != 0L)
1299             return 13;
1300          if ((active0 & 0x260000000L) != 0L)
1301          {
1302             jjmatchedKind = 37;
1303             jjmatchedPos = 5;
1304             return 13;
1305          }
1306          return -1;
1307       case 6:
1308          if ((active0 & 0x240000000L) != 0L)
1309          {
1310             jjmatchedKind = 37;
1311             jjmatchedPos = 6;
1312             return 13;
1313          }
1314          if ((active0 & 0x20000000L) != 0L)
1315             return 13;
1316          return -1;
1317       case 7:
1318          if ((active0 & 0x200000000L) != 0L)
1319             return 13;
1320          if ((active0 & 0x40000000L) != 0L)
1321          {
1322             jjmatchedKind = 37;
1323             jjmatchedPos = 7;
1324             return 13;
1325          }
1326          return -1;
1327       default :
1328          return -1;
1329    }
1330 }
1331 private static final int jjStartNfa_4(int pos, long active0)
1332 {
1333    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
1334 }
1335 static private final int jjStartNfaWithStates_4(int pos, int kind, int state)
1336 {
1337    jjmatchedKind = kind;
1338    jjmatchedPos = pos;
1339    try { curChar = input_stream.readChar(); }
1340    catch(java.io.IOException e) { return pos + 1; }
1341    return jjMoveNfa_4(state, pos + 1);
1342 }
1343 static private final int jjMoveStringLiteralDfa0_4()
1344 {
1345    switch(curChar)
1346    {
1347       case 33:
1348          return jjStopAtPos(0, 35);
1349       case 41:
1350          return jjStopAtPos(0, 41);
1351       case 44:
1352          return jjStopAtPos(0, 3);
1353       case 46:
1354          return jjStartNfaWithStates_4(0, 4, 12);
1355       case 97:
1356          return jjMoveStringLiteralDfa1_4(0x200000000L);
1357       case 102:
1358          return jjMoveStringLiteralDfa1_4(0x400000000L);
1359       case 112:
1360          return jjMoveStringLiteralDfa1_4(0xe0000000L);
1361       case 115:
1362          return jjMoveStringLiteralDfa1_4(0x100000000L);
1363       default :
1364          return jjMoveNfa_4(0, 0);
1365    }
1366 }
1367 static private final int jjMoveStringLiteralDfa1_4(long active0)
1368 {
1369    try { curChar = input_stream.readChar(); }
1370    catch(java.io.IOException e) {
1371       jjStopStringLiteralDfa_4(0, active0);
1372       return 1;
1373    }
1374    switch(curChar)
1375    {
1376       case 98:
1377          return jjMoveStringLiteralDfa2_4(active0, 0x200000000L);
1378       case 105:
1379          return jjMoveStringLiteralDfa2_4(active0, 0x400000000L);
1380       case 114:
1381          return jjMoveStringLiteralDfa2_4(active0, 0x60000000L);
1382       case 116:
1383          return jjMoveStringLiteralDfa2_4(active0, 0x100000000L);
1384       case 117:
1385          return jjMoveStringLiteralDfa2_4(active0, 0x80000000L);
1386       default :
1387          break;
1388    }
1389    return jjStartNfa_4(0, active0);
1390 }
1391 static private final int jjMoveStringLiteralDfa2_4(long old0, long active0)
1392 {
1393    if (((active0 &= old0)) == 0L)
1394       return jjStartNfa_4(0, old0); 
1395    try { curChar = input_stream.readChar(); }
1396    catch(java.io.IOException e) {
1397       jjStopStringLiteralDfa_4(1, active0);
1398       return 2;
1399    }
1400    switch(curChar)
1401    {
1402       case 97:
1403          return jjMoveStringLiteralDfa3_4(active0, 0x100000000L);
1404       case 98:
1405          return jjMoveStringLiteralDfa3_4(active0, 0x80000000L);
1406       case 105:
1407          return jjMoveStringLiteralDfa3_4(active0, 0x20000000L);
1408       case 110:
1409          return jjMoveStringLiteralDfa3_4(active0, 0x400000000L);
1410       case 111:
1411          return jjMoveStringLiteralDfa3_4(active0, 0x40000000L);
1412       case 115:
1413          return jjMoveStringLiteralDfa3_4(active0, 0x200000000L);
1414       default :
1415          break;
1416    }
1417    return jjStartNfa_4(1, active0);
1418 }
1419 static private final int jjMoveStringLiteralDfa3_4(long old0, long active0)
1420 {
1421    if (((active0 &= old0)) == 0L)
1422       return jjStartNfa_4(1, old0); 
1423    try { curChar = input_stream.readChar(); }
1424    catch(java.io.IOException e) {
1425       jjStopStringLiteralDfa_4(2, active0);
1426       return 3;
1427    }
1428    switch(curChar)
1429    {
1430       case 97:
1431          return jjMoveStringLiteralDfa4_4(active0, 0x400000000L);
1432       case 108:
1433          return jjMoveStringLiteralDfa4_4(active0, 0x80000000L);
1434       case 116:
1435          return jjMoveStringLiteralDfa4_4(active0, 0x340000000L);
1436       case 118:
1437          return jjMoveStringLiteralDfa4_4(active0, 0x20000000L);
1438       default :
1439          break;
1440    }
1441    return jjStartNfa_4(2, active0);
1442 }
1443 static private final int jjMoveStringLiteralDfa4_4(long old0, long active0)
1444 {
1445    if (((active0 &= old0)) == 0L)
1446       return jjStartNfa_4(2, old0); 
1447    try { curChar = input_stream.readChar(); }
1448    catch(java.io.IOException e) {
1449       jjStopStringLiteralDfa_4(3, active0);
1450       return 4;
1451    }
1452    switch(curChar)
1453    {
1454       case 97:
1455          return jjMoveStringLiteralDfa5_4(active0, 0x20000000L);
1456       case 101:
1457          return jjMoveStringLiteralDfa5_4(active0, 0x40000000L);
1458       case 105:
1459          return jjMoveStringLiteralDfa5_4(active0, 0x180000000L);
1460       case 108:
1461          if ((active0 & 0x400000000L) != 0L)
1462             return jjStartNfaWithStates_4(4, 34, 13);
1463          break;
1464       case 114:
1465          return jjMoveStringLiteralDfa5_4(active0, 0x200000000L);
1466       default :
1467          break;
1468    }
1469    return jjStartNfa_4(3, active0);
1470 }
1471 static private final int jjMoveStringLiteralDfa5_4(long old0, long active0)
1472 {
1473    if (((active0 &= old0)) == 0L)
1474       return jjStartNfa_4(3, old0); 
1475    try { curChar = input_stream.readChar(); }
1476    catch(java.io.IOException e) {
1477       jjStopStringLiteralDfa_4(4, active0);
1478       return 5;
1479    }
1480    switch(curChar)
1481    {
1482       case 97:
1483          return jjMoveStringLiteralDfa6_4(active0, 0x200000000L);
1484       case 99:
1485          if ((active0 & 0x80000000L) != 0L)
1486             return jjStartNfaWithStates_4(5, 31, 13);
1487          else if ((active0 & 0x100000000L) != 0L)
1488             return jjStartNfaWithStates_4(5, 32, 13);
1489          return jjMoveStringLiteralDfa6_4(active0, 0x40000000L);
1490       case 116:
1491          return jjMoveStringLiteralDfa6_4(active0, 0x20000000L);
1492       default :
1493          break;
1494    }
1495    return jjStartNfa_4(4, active0);
1496 }
1497 static private final int jjMoveStringLiteralDfa6_4(long old0, long active0)
1498 {
1499    if (((active0 &= old0)) == 0L)
1500       return jjStartNfa_4(4, old0); 
1501    try { curChar = input_stream.readChar(); }
1502    catch(java.io.IOException e) {
1503       jjStopStringLiteralDfa_4(5, active0);
1504       return 6;
1505    }
1506    switch(curChar)
1507    {
1508       case 99:
1509          return jjMoveStringLiteralDfa7_4(active0, 0x200000000L);
1510       case 101:
1511          if ((active0 & 0x20000000L) != 0L)
1512             return jjStartNfaWithStates_4(6, 29, 13);
1513          break;
1514       case 116:
1515          return jjMoveStringLiteralDfa7_4(active0, 0x40000000L);
1516       default :
1517          break;
1518    }
1519    return jjStartNfa_4(5, active0);
1520 }
1521 static private final int jjMoveStringLiteralDfa7_4(long old0, long active0)
1522 {
1523    if (((active0 &= old0)) == 0L)
1524       return jjStartNfa_4(5, old0); 
1525    try { curChar = input_stream.readChar(); }
1526    catch(java.io.IOException e) {
1527       jjStopStringLiteralDfa_4(6, active0);
1528       return 7;
1529    }
1530    switch(curChar)
1531    {
1532       case 101:
1533          return jjMoveStringLiteralDfa8_4(active0, 0x40000000L);
1534       case 116:
1535          if ((active0 & 0x200000000L) != 0L)
1536             return jjStartNfaWithStates_4(7, 33, 13);
1537          break;
1538       default :
1539          break;
1540    }
1541    return jjStartNfa_4(6, active0);
1542 }
1543 static private final int jjMoveStringLiteralDfa8_4(long old0, long active0)
1544 {
1545    if (((active0 &= old0)) == 0L)
1546       return jjStartNfa_4(6, old0); 
1547    try { curChar = input_stream.readChar(); }
1548    catch(java.io.IOException e) {
1549       jjStopStringLiteralDfa_4(7, active0);
1550       return 8;
1551    }
1552    switch(curChar)
1553    {
1554       case 100:
1555          if ((active0 & 0x40000000L) != 0L)
1556             return jjStartNfaWithStates_4(8, 30, 13);
1557          break;
1558       default :
1559          break;
1560    }
1561    return jjStartNfa_4(7, active0);
1562 }
1563 static private final int jjMoveNfa_4(int startState, int curPos)
1564 {
1565    int[] nextStates;
1566    int startsAt = 0;
1567    jjnewStateCnt = 13;
1568    int i = 1;
1569    jjstateSet[0] = startState;
1570    int j, kind = 0x7fffffff;
1571    for (;;)
1572    {
1573       if (++jjround == 0x7fffffff)
1574          ReInitRounds();
1575       if (curChar < 64)
1576       {
1577          long l = 1L << curChar;
1578          MatchLoop: do
1579          {
1580             switch(jjstateSet[--i])
1581             {
1582                case 13:
1583                   if ((0x3ff0c1800000000L & l) != 0L)
1584                   {
1585                      if (kind > 37)
1586                         kind = 37;
1587                      jjCheckNAddTwoStates(4, 5);
1588                   }
1589                   else if (curChar == 46)
1590                      jjCheckNAddStates(14, 16);
1591                   break;
1592                case 12:
1593                   if (curChar == 46)
1594                   {
1595                      if (kind > 37)
1596                         kind = 37;
1597                      jjCheckNAddTwoStates(4, 5);
1598                   }
1599                   if (curChar == 46)
1600                   {
1601                      if (kind > 7)
1602                         kind = 7;
1603                   }
1604                   break;
1605                case 0:
1606                   if ((0x3ff0c1800000000L & l) != 0L)
1607                   {
1608                      if (kind > 37)
1609                         kind = 37;
1610                      jjCheckNAddTwoStates(4, 5);
1611                   }
1612                   else if (curChar == 46)
1613                      jjCheckNAddTwoStates(12, 6);
1614                   break;
1615                case 1:
1616                   if ((0x3ff081800000000L & l) == 0L)
1617                      break;
1618                   if (kind > 36)
1619                      kind = 36;
1620                   jjCheckNAddTwoStates(1, 2);
1621                   break;
1622                case 2:
1623                   if (curChar == 46)
1624                      jjCheckNAdd(3);
1625                   break;
1626                case 3:
1627                   if ((0x3ff081800000000L & l) == 0L)
1628                      break;
1629                   if (kind > 36)
1630                      kind = 36;
1631                   jjCheckNAddTwoStates(2, 3);
1632                   break;
1633                case 4:
1634                   if ((0x3ff0c1800000000L & l) == 0L)
1635                      break;
1636                   if (kind > 37)
1637                      kind = 37;
1638                   jjCheckNAddTwoStates(4, 5);
1639                   break;
1640                case 5:
1641                   if (curChar == 46)
1642                      jjCheckNAddStates(14, 16);
1643                   break;
1644                case 6:
1645                   if (curChar != 46)
1646                      break;
1647                   if (kind > 37)
1648                      kind = 37;
1649                   jjCheckNAddTwoStates(4, 5);
1650                   break;
1651                case 7:
1652                   if ((0x3ff0c1800000000L & l) == 0L)
1653                      break;
1654                   if (kind > 37)
1655                      kind = 37;
1656                   jjCheckNAddTwoStates(7, 8);
1657                   break;
1658                case 8:
1659                   if (curChar == 46)
1660                      jjCheckNAddStates(17, 19);
1661                   break;
1662                case 9:
1663                   if (curChar == 46)
1664                      jjCheckNAdd(10);
1665                   break;
1666                case 10:
1667                   if (curChar != 46)
1668                      break;
1669                   if (kind > 37)
1670                      kind = 37;
1671                   jjCheckNAddTwoStates(7, 8);
1672                   break;
1673                case 11:
1674                   if (curChar == 46)
1675                      jjCheckNAddTwoStates(12, 6);
1676                   break;
1677                default : break;
1678             }
1679          } while(i != startsAt);
1680       }
1681       else if (curChar < 128)
1682       {
1683          long l = 1L << (curChar & 077);
1684          MatchLoop: do
1685          {
1686             switch(jjstateSet[--i])
1687             {
1688                case 13:
1689                case 4:
1690                   if ((0x7fffffe87fffffeL & l) == 0L)
1691                      break;
1692                   if (kind > 37)
1693                      kind = 37;
1694                   jjCheckNAddTwoStates(4, 5);
1695                   break;
1696                case 0:
1697                   if ((0x7fffffe87fffffeL & l) != 0L)
1698                   {
1699                      if (kind > 37)
1700                         kind = 37;
1701                      jjCheckNAddTwoStates(4, 5);
1702                   }
1703                   else if (curChar == 64)
1704                      jjCheckNAdd(1);
1705                   break;
1706                case 1:
1707                   if ((0x7fffffe87fffffeL & l) == 0L)
1708                      break;
1709                   if (kind > 36)
1710                      kind = 36;
1711                   jjCheckNAddTwoStates(1, 2);
1712                   break;
1713                case 3:
1714                   if ((0x7fffffe87fffffeL & l) == 0L)
1715                      break;
1716                   if (kind > 36)
1717                      kind = 36;
1718                   jjCheckNAddTwoStates(2, 3);
1719                   break;
1720                case 7:
1721                   if ((0x7fffffe87fffffeL & l) == 0L)
1722                      break;
1723                   if (kind > 37)
1724                      kind = 37;
1725                   jjAddStates(20, 21);
1726                   break;
1727                default : break;
1728             }
1729          } while(i != startsAt);
1730       }
1731       else
1732       {
1733          int i2 = (curChar & 0xff) >> 6;
1734          long l2 = 1L << (curChar & 077);
1735          MatchLoop: do
1736          {
1737             switch(jjstateSet[--i])
1738             {
1739                default : break;
1740             }
1741          } while(i != startsAt);
1742       }
1743       if (kind != 0x7fffffff)
1744       {
1745          jjmatchedKind = kind;
1746          jjmatchedPos = curPos;
1747          kind = 0x7fffffff;
1748       }
1749       ++curPos;
1750       if ((i = jjnewStateCnt) == (startsAt = 13 - (jjnewStateCnt = startsAt)))
1751          return curPos;
1752       try { curChar = input_stream.readChar(); }
1753       catch(java.io.IOException e) { return curPos; }
1754    }
1755 }
1756 private static final int jjStopStringLiteralDfa_2(int pos, long active0, long active1)
1757 {
1758    switch (pos)
1759    {
1760       case 0:
1761          if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x7L) != 0L)
1762          {
1763             jjmatchedKind = 70;
1764             return 23;
1765          }
1766          if ((active0 & 0x10L) != 0L)
1767             return 5;
1768          return -1;
1769       case 1:
1770          if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x7L) != 0L)
1771          {
1772             jjmatchedKind = 70;
1773             jjmatchedPos = 1;
1774             return 23;
1775          }
1776          return -1;
1777       case 2:
1778          if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x7L) != 0L)
1779          {
1780             jjmatchedKind = 70;
1781             jjmatchedPos = 2;
1782             return 23;
1783          }
1784          return -1;
1785       case 3:
1786          if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x7L) != 0L)
1787          {
1788             jjmatchedKind = 70;
1789             jjmatchedPos = 3;
1790             return 23;
1791          }
1792          return -1;
1793       case 4:
1794          if ((active0 & 0xf000000000000000L) != 0L || (active1 & 0x5L) != 0L)
1795          {
1796             jjmatchedKind = 70;
1797             jjmatchedPos = 4;
1798             return 23;
1799          }
1800          if ((active1 & 0x2L) != 0L)
1801             return 23;
1802          return -1;
1803       case 5:
1804          if ((active0 & 0x3000000000000000L) != 0L || (active1 & 0x5L) != 0L)
1805          {
1806             jjmatchedKind = 70;
1807             jjmatchedPos = 5;
1808             return 23;
1809          }
1810          if ((active0 & 0xc000000000000000L) != 0L)
1811             return 23;
1812          return -1;
1813       case 6:
1814          if ((active0 & 0x2000000000000000L) != 0L || (active1 & 0x5L) != 0L)
1815          {
1816             jjmatchedKind = 70;
1817             jjmatchedPos = 6;
1818             return 23;
1819          }
1820          if ((active0 & 0x1000000000000000L) != 0L)
1821             return 23;
1822          return -1;
1823       case 7:
1824          if ((active0 & 0x2000000000000000L) != 0L || (active1 & 0x4L) != 0L)
1825          {
1826             jjmatchedKind = 70;
1827             jjmatchedPos = 7;
1828             return 23;
1829          }
1830          if ((active1 & 0x1L) != 0L)
1831             return 23;
1832          return -1;
1833       default :
1834          return -1;
1835    }
1836 }
1837 private static final int jjStartNfa_2(int pos, long active0, long active1)
1838 {
1839    return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0, active1), pos + 1);
1840 }
1841 static private final int jjStartNfaWithStates_2(int pos, int kind, int state)
1842 {
1843    jjmatchedKind = kind;
1844    jjmatchedPos = pos;
1845    try { curChar = input_stream.readChar(); }
1846    catch(java.io.IOException e) { return pos + 1; }
1847    return jjMoveNfa_2(state, pos + 1);
1848 }
1849 static private final int jjMoveStringLiteralDfa0_2()
1850 {
1851    switch(curChar)
1852    {
1853       case 33:
1854          return jjStopAtPos(0, 67);
1855       case 41:
1856          return jjStopAtPos(0, 74);
1857       case 44:
1858          return jjStopAtPos(0, 3);
1859       case 46:
1860          return jjStartNfaWithStates_2(0, 4, 5);
1861       case 97:
1862          return jjMoveStringLiteralDfa1_2(0x0L, 0x1L);
1863       case 102:
1864          return jjMoveStringLiteralDfa1_2(0x0L, 0x2L);
1865       case 112:
1866          return jjMoveStringLiteralDfa1_2(0x7000000000000000L, 0x0L);
1867       case 115:
1868          return jjMoveStringLiteralDfa1_2(0x8000000000000000L, 0x0L);
1869       case 116:
1870          return jjMoveStringLiteralDfa1_2(0x0L, 0x4L);
1871       default :
1872          return jjMoveNfa_2(0, 0);
1873    }
1874 }
1875 static private final int jjMoveStringLiteralDfa1_2(long active0, long active1)
1876 {
1877    try { curChar = input_stream.readChar(); }
1878    catch(java.io.IOException e) {
1879       jjStopStringLiteralDfa_2(0, active0, active1);
1880       return 1;
1881    }
1882    switch(curChar)
1883    {
1884       case 98:
1885          return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0x1L);
1886       case 105:
1887          return jjMoveStringLiteralDfa2_2(active0, 0L, active1, 0x2L);
1888       case 114:
1889          return jjMoveStringLiteralDfa2_2(active0, 0x3000000000000000L, active1, 0x4L);
1890       case 116:
1891          return jjMoveStringLiteralDfa2_2(active0, 0x8000000000000000L, active1, 0L);
1892       case 117:
1893          return jjMoveStringLiteralDfa2_2(active0, 0x4000000000000000L, active1, 0L);
1894       default :
1895          break;
1896    }
1897    return jjStartNfa_2(0, active0, active1);
1898 }
1899 static private final int jjMoveStringLiteralDfa2_2(long old0, long active0, long old1, long active1)
1900 {
1901    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1902       return jjStartNfa_2(0, old0, old1); 
1903    try { curChar = input_stream.readChar(); }
1904    catch(java.io.IOException e) {
1905       jjStopStringLiteralDfa_2(1, active0, active1);
1906       return 2;
1907    }
1908    switch(curChar)
1909    {
1910       case 97:
1911          return jjMoveStringLiteralDfa3_2(active0, 0x8000000000000000L, active1, 0x4L);
1912       case 98:
1913          return jjMoveStringLiteralDfa3_2(active0, 0x4000000000000000L, active1, 0L);
1914       case 105:
1915          return jjMoveStringLiteralDfa3_2(active0, 0x1000000000000000L, active1, 0L);
1916       case 110:
1917          return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x2L);
1918       case 111:
1919          return jjMoveStringLiteralDfa3_2(active0, 0x2000000000000000L, active1, 0L);
1920       case 115:
1921          return jjMoveStringLiteralDfa3_2(active0, 0L, active1, 0x1L);
1922       default :
1923          break;
1924    }
1925    return jjStartNfa_2(1, active0, active1);
1926 }
1927 static private final int jjMoveStringLiteralDfa3_2(long old0, long active0, long old1, long active1)
1928 {
1929    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1930       return jjStartNfa_2(1, old0, old1); 
1931    try { curChar = input_stream.readChar(); }
1932    catch(java.io.IOException e) {
1933       jjStopStringLiteralDfa_2(2, active0, active1);
1934       return 3;
1935    }
1936    switch(curChar)
1937    {
1938       case 97:
1939          return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x2L);
1940       case 108:
1941          return jjMoveStringLiteralDfa4_2(active0, 0x4000000000000000L, active1, 0L);
1942       case 110:
1943          return jjMoveStringLiteralDfa4_2(active0, 0L, active1, 0x4L);
1944       case 116:
1945          return jjMoveStringLiteralDfa4_2(active0, 0xa000000000000000L, active1, 0x1L);
1946       case 118:
1947          return jjMoveStringLiteralDfa4_2(active0, 0x1000000000000000L, active1, 0L);
1948       default :
1949          break;
1950    }
1951    return jjStartNfa_2(2, active0, active1);
1952 }
1953 static private final int jjMoveStringLiteralDfa4_2(long old0, long active0, long old1, long active1)
1954 {
1955    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1956       return jjStartNfa_2(2, old0, old1); 
1957    try { curChar = input_stream.readChar(); }
1958    catch(java.io.IOException e) {
1959       jjStopStringLiteralDfa_2(3, active0, active1);
1960       return 4;
1961    }
1962    switch(curChar)
1963    {
1964       case 97:
1965          return jjMoveStringLiteralDfa5_2(active0, 0x1000000000000000L, active1, 0L);
1966       case 101:
1967          return jjMoveStringLiteralDfa5_2(active0, 0x2000000000000000L, active1, 0L);
1968       case 105:
1969          return jjMoveStringLiteralDfa5_2(active0, 0xc000000000000000L, active1, 0L);
1970       case 108:
1971          if ((active1 & 0x2L) != 0L)
1972             return jjStartNfaWithStates_2(4, 65, 23);
1973          break;
1974       case 114:
1975          return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0x1L);
1976       case 115:
1977          return jjMoveStringLiteralDfa5_2(active0, 0L, active1, 0x4L);
1978       default :
1979          break;
1980    }
1981    return jjStartNfa_2(3, active0, active1);
1982 }
1983 static private final int jjMoveStringLiteralDfa5_2(long old0, long active0, long old1, long active1)
1984 {
1985    if (((active0 &= old0) | (active1 &= old1)) == 0L)
1986       return jjStartNfa_2(3, old0, old1); 
1987    try { curChar = input_stream.readChar(); }
1988    catch(java.io.IOException e) {
1989       jjStopStringLiteralDfa_2(4, active0, active1);
1990       return 5;
1991    }
1992    switch(curChar)
1993    {
1994       case 97:
1995          return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x1L);
1996       case 99:
1997          if ((active0 & 0x4000000000000000L) != 0L)
1998             return jjStartNfaWithStates_2(5, 62, 23);
1999          else if ((active0 & 0x8000000000000000L) != 0L)
2000             return jjStartNfaWithStates_2(5, 63, 23);
2001          return jjMoveStringLiteralDfa6_2(active0, 0x2000000000000000L, active1, 0L);
2002       case 105:
2003          return jjMoveStringLiteralDfa6_2(active0, 0L, active1, 0x4L);
2004       case 116:
2005          return jjMoveStringLiteralDfa6_2(active0, 0x1000000000000000L, active1, 0L);
2006       default :
2007          break;
2008    }
2009    return jjStartNfa_2(4, active0, active1);
2010 }
2011 static private final int jjMoveStringLiteralDfa6_2(long old0, long active0, long old1, long active1)
2012 {
2013    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2014       return jjStartNfa_2(4, old0, old1); 
2015    try { curChar = input_stream.readChar(); }
2016    catch(java.io.IOException e) {
2017       jjStopStringLiteralDfa_2(5, active0, active1);
2018       return 6;
2019    }
2020    switch(curChar)
2021    {
2022       case 99:
2023          return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x1L);
2024       case 101:
2025          if ((active0 & 0x1000000000000000L) != 0L)
2026             return jjStartNfaWithStates_2(6, 60, 23);
2027          return jjMoveStringLiteralDfa7_2(active0, 0L, active1, 0x4L);
2028       case 116:
2029          return jjMoveStringLiteralDfa7_2(active0, 0x2000000000000000L, active1, 0L);
2030       default :
2031          break;
2032    }
2033    return jjStartNfa_2(5, active0, active1);
2034 }
2035 static private final int jjMoveStringLiteralDfa7_2(long old0, long active0, long old1, long active1)
2036 {
2037    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2038       return jjStartNfa_2(5, old0, old1); 
2039    try { curChar = input_stream.readChar(); }
2040    catch(java.io.IOException e) {
2041       jjStopStringLiteralDfa_2(6, active0, active1);
2042       return 7;
2043    }
2044    switch(curChar)
2045    {
2046       case 101:
2047          return jjMoveStringLiteralDfa8_2(active0, 0x2000000000000000L, active1, 0L);
2048       case 110:
2049          return jjMoveStringLiteralDfa8_2(active0, 0L, active1, 0x4L);
2050       case 116:
2051          if ((active1 & 0x1L) != 0L)
2052             return jjStartNfaWithStates_2(7, 64, 23);
2053          break;
2054       default :
2055          break;
2056    }
2057    return jjStartNfa_2(6, active0, active1);
2058 }
2059 static private final int jjMoveStringLiteralDfa8_2(long old0, long active0, long old1, long active1)
2060 {
2061    if (((active0 &= old0) | (active1 &= old1)) == 0L)
2062       return jjStartNfa_2(6, old0, old1); 
2063    try { curChar = input_stream.readChar(); }
2064    catch(java.io.IOException e) {
2065       jjStopStringLiteralDfa_2(7, active0, active1);
2066       return 8;
2067    }
2068    switch(curChar)
2069    {
2070       case 100:
2071          if ((active0 & 0x2000000000000000L) != 0L)
2072             return jjStartNfaWithStates_2(8, 61, 23);
2073          break;
2074       case 116:
2075          if ((active1 & 0x4L) != 0L)
2076             return jjStartNfaWithStates_2(8, 66, 23);
2077          break;
2078       default :
2079          break;
2080    }
2081    return jjStartNfa_2(7, active0, active1);
2082 }
2083 static private final int jjMoveNfa_2(int startState, int curPos)
2084 {
2085    int[] nextStates;
2086    int startsAt = 0;
2087    jjnewStateCnt = 23;
2088    int i = 1;
2089    jjstateSet[0] = startState;
2090    int j, kind = 0x7fffffff;
2091    for (;;)
2092    {
2093       if (++jjround == 0x7fffffff)
2094          ReInitRounds();
2095       if (curChar < 64)
2096       {
2097          long l = 1L << curChar;
2098          MatchLoop: do
2099          {
2100             switch(jjstateSet[--i])
2101             {
2102                case 5:
2103                   if (curChar == 46)
2104                      jjCheckNAddStates(22, 24);
2105                   if (curChar == 46)
2106                   {
2107                      if (kind > 70)
2108                         kind = 70;
2109                      jjCheckNAddTwoStates(7, 8);
2110                   }
2111                   if (curChar == 46)
2112                   {
2113                      if (kind > 7)
2114                         kind = 7;
2115                   }
2116                   break;
2117                case 23:
2118                   if ((0x3ff0c1800000000L & l) != 0L)
2119                      jjCheckNAddStates(22, 24);
2120                   else if (curChar == 46)
2121                      jjCheckNAddStates(25, 27);
2122                   if ((0x3ff0c1800000000L & l) != 0L)
2123                   {
2124                      if (kind > 70)
2125                         kind = 70;
2126                      jjCheckNAddTwoStates(7, 8);
2127                   }
2128                   else if (curChar == 46)
2129                      jjCheckNAddStates(28, 30);
2130                   break;
2131                case 0:
2132                   if ((0x3ff0c1800000000L & l) != 0L)
2133                   {
2134                      if (kind > 70)
2135                         kind = 70;
2136                      jjCheckNAddStates(31, 35);
2137                   }
2138                   else if (curChar == 46)
2139                      jjCheckNAddStates(36, 38);
2140                   break;
2141                case 1:
2142                   if ((0x3ff081800000000L & l) == 0L)
2143                      break;
2144                   if (kind > 68)
2145                      kind = 68;
2146                   jjCheckNAddTwoStates(1, 2);
2147                   break;
2148                case 2:
2149                   if (curChar == 46)
2150                      jjCheckNAdd(3);
2151                   break;
2152                case 3:
2153                   if ((0x3ff081800000000L & l) == 0L)
2154                      break;
2155                   if (kind > 68)
2156                      kind = 68;
2157                   jjCheckNAddTwoStates(2, 3);
2158                   break;
2159                case 4:
2160                   if (curChar == 46)
2161                      jjCheckNAddStates(36, 38);
2162                   break;
2163                case 6:
2164                   if (curChar != 46)
2165                      break;
2166                   if (kind > 70)
2167                      kind = 70;
2168                   jjCheckNAddTwoStates(7, 8);
2169                   break;
2170                case 7:
2171                   if ((0x3ff0c1800000000L & l) == 0L)
2172                      break;
2173                   if (kind > 70)
2174                      kind = 70;
2175                   jjCheckNAddTwoStates(7, 8);
2176                   break;
2177                case 8:
2178                   if (curChar == 46)
2179                      jjCheckNAddStates(25, 27);
2180                   break;
2181                case 9:
2182                   if ((0x3ff0c1800000000L & l) == 0L)
2183                      break;
2184                   if (kind > 70)
2185                      kind = 70;
2186                   jjCheckNAddTwoStates(9, 10);
2187                   break;
2188                case 10:
2189                   if (curChar == 46)
2190                      jjCheckNAddStates(39, 41);
2191                   break;
2192                case 11:
2193                   if (curChar == 46)
2194                      jjCheckNAdd(12);
2195                   break;
2196                case 12:
2197                   if (curChar != 46)
2198                      break;
2199                   if (kind > 70)
2200                      kind = 70;
2201                   jjCheckNAddTwoStates(9, 10);
2202                   break;
2203                case 13:
2204                   if (curChar == 46)
2205                      jjCheckNAddStates(22, 24);
2206                   break;
2207                case 14:
2208                   if ((0x3ff0c1800000000L & l) != 0L)
2209                      jjCheckNAddStates(22, 24);
2210                   break;
2211                case 17:
2212                   if (curChar == 46)
2213                      jjCheckNAddStates(28, 30);
2214                   break;
2215                case 18:
2216                   if ((0x3ff0c1800000000L & l) != 0L)
2217                      jjCheckNAddStates(42, 44);
2218                   break;
2219                case 19:
2220                   if (curChar == 46)
2221                      jjCheckNAddStates(45, 47);
2222                   break;
2223                case 20:
2224                   if (curChar == 46)
2225                      jjCheckNAdd(21);
2226                   break;
2227                case 21:
2228                   if (curChar == 46)
2229                      jjCheckNAddStates(42, 44);
2230                   break;
2231                case 22:
2232                   if ((0x3ff0c1800000000L & l) == 0L)
2233                      break;
2234                   if (kind > 70)
2235                      kind = 70;
2236                   jjCheckNAddStates(31, 35);
2237                   break;
2238                default : break;
2239             }
2240          } while(i != startsAt);
2241       }
2242       else if (curChar < 128)
2243       {
2244          long l = 1L << (curChar & 077);
2245          MatchLoop: do
2246          {
2247             switch(jjstateSet[--i])
2248             {
2249                case 23:
2250                   if ((0x7fffffe87fffffeL & l) != 0L)
2251                      jjCheckNAddStates(22, 24);
2252                   else if (curChar == 91)
2253                      jjstateSet[jjnewStateCnt++] = 15;
2254                   if ((0x7fffffe87fffffeL & l) != 0L)
2255                   {
2256                      if (kind > 70)
2257                         kind = 70;
2258                      jjCheckNAddTwoStates(7, 8);
2259                   }
2260                   break;
2261                case 0:
2262                   if ((0x7fffffe87fffffeL & l) != 0L)
2263                   {
2264                      if (kind > 70)
2265                         kind = 70;
2266                      jjCheckNAddStates(31, 35);
2267                   }
2268                   else if (curChar == 64)
2269                      jjCheckNAdd(1);
2270                   break;
2271                case 1:
2272                   if ((0x7fffffe87fffffeL & l) == 0L)
2273                      break;
2274                   if (kind > 68)
2275                      kind = 68;
2276                   jjCheckNAddTwoStates(1, 2);
2277                   break;
2278                case 3:
2279                   if ((0x7fffffe87fffffeL & l) == 0L)
2280                      break;
2281                   if (kind > 68)
2282                      kind = 68;
2283                   jjCheckNAddTwoStates(2, 3);
2284                   break;
2285                case 7:
2286                   if ((0x7fffffe87fffffeL & l) == 0L)
2287                      break;
2288                   if (kind > 70)
2289                      kind = 70;
2290                   jjCheckNAddTwoStates(7, 8);
2291                   break;
2292                case 9:
2293                   if ((0x7fffffe87fffffeL & l) == 0L)
2294                      break;
2295                   if (kind > 70)
2296                      kind = 70;
2297                   jjAddStates(48, 49);
2298                   break;
2299                case 14:
2300                   if ((0x7fffffe87fffffeL & l) != 0L)
2301                      jjCheckNAddStates(22, 24);
2302                   break;
2303                case 15:
2304                   if (curChar != 93)
2305                      break;
2306                   kind = 71;
2307                   jjCheckNAdd(16);
2308                   break;
2309                case 16:
2310                   if (curChar == 91)
2311                      jjstateSet[jjnewStateCnt++] = 15;
2312                   break;
2313                case 18:
2314                   if ((0x7fffffe87fffffeL & l) != 0L)
2315                      jjCheckNAddStates(42, 44);
2316                   break;
2317                case 22:
2318                   if ((0x7fffffe87fffffeL & l) == 0L)
2319                      break;
2320                   if (kind > 70)
2321                      kind = 70;
2322                   jjCheckNAddStates(31, 35);
2323                   break;
2324                default : break;
2325             }
2326          } while(i != startsAt);
2327       }
2328       else
2329       {
2330          int i2 = (curChar & 0xff) >> 6;
2331          long l2 = 1L << (curChar & 077);
2332          MatchLoop: do
2333          {
2334             switch(jjstateSet[--i])
2335             {
2336                default : break;
2337             }
2338          } while(i != startsAt);
2339       }
2340       if (kind != 0x7fffffff)
2341       {
2342          jjmatchedKind = kind;
2343          jjmatchedPos = curPos;
2344          kind = 0x7fffffff;
2345       }
2346       ++curPos;
2347       if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
2348          return curPos;
2349       try { curChar = input_stream.readChar(); }
2350       catch(java.io.IOException e) { return curPos; }
2351    }
2352 }
2353 private static final int jjStopStringLiteralDfa_3(int pos, long active0)
2354 {
2355    switch (pos)
2356    {
2357       case 0:
2358          if ((active0 & 0x10L) != 0L)
2359             return 5;
2360          if ((active0 & 0x7fc0000000000L) != 0L)
2361          {
2362             jjmatchedKind = 54;
2363             return 23;
2364          }
2365          return -1;
2366       case 1:
2367          if ((active0 & 0x7fc0000000000L) != 0L)
2368          {
2369             jjmatchedKind = 54;
2370             jjmatchedPos = 1;
2371             return 23;
2372          }
2373          return -1;
2374       case 2:
2375          if ((active0 & 0x7fc0000000000L) != 0L)
2376          {
2377             jjmatchedKind = 54;
2378             jjmatchedPos = 2;
2379             return 23;
2380          }
2381          return -1;
2382       case 3:
2383          if ((active0 & 0x7fc0000000000L) != 0L)
2384          {
2385             jjmatchedKind = 54;
2386             jjmatchedPos = 3;
2387             return 23;
2388          }
2389          return -1;
2390       case 4:
2391          if ((active0 & 0x77c0000000000L) != 0L)
2392          {
2393             jjmatchedKind = 54;
2394             jjmatchedPos = 4;
2395             return 23;
2396          }
2397          if ((active0 & 0x800000000000L) != 0L)
2398             return 23;
2399          return -1;
2400       case 5:
2401          if ((active0 & 0x2580000000000L) != 0L)
2402          {
2403             if (jjmatchedPos != 5)
2404             {
2405                jjmatchedKind = 54;
2406                jjmatchedPos = 5;
2407             }
2408             return 23;
2409          }
2410          if ((active0 & 0x5240000000000L) != 0L)
2411             return 23;
2412          return -1;
2413       case 6:
2414          if ((active0 & 0x6480000000000L) != 0L)
2415          {
2416             jjmatchedKind = 54;
2417             jjmatchedPos = 6;
2418             return 23;
2419          }
2420          if ((active0 & 0x100000000000L) != 0L)
2421             return 23;
2422          return -1;
2423       case 7:
2424          if ((active0 & 0x6080000000000L) != 0L)
2425          {
2426             jjmatchedKind = 54;
2427             jjmatchedPos = 7;
2428             return 23;
2429          }
2430          if ((active0 & 0x400000000000L) != 0L)
2431             return 23;
2432          return -1;
2433       case 8:
2434          if ((active0 & 0x6000000000000L) != 0L)
2435          {
2436             jjmatchedKind = 54;
2437             jjmatchedPos = 8;
2438             return 23;
2439          }
2440          if ((active0 & 0x80000000000L) != 0L)
2441             return 23;
2442          return -1;
2443       case 9:
2444          if ((active0 & 0x6000000000000L) != 0L)
2445          {
2446             jjmatchedKind = 54;
2447             jjmatchedPos = 9;
2448             return 23;
2449          }
2450          return -1;
2451       case 10:
2452          if ((active0 & 0x6000000000000L) != 0L)
2453          {
2454             jjmatchedKind = 54;
2455             jjmatchedPos = 10;
2456             return 23;
2457          }
2458          return -1;
2459       case 11:
2460          if ((active0 & 0x4000000000000L) != 0L)
2461          {
2462             jjmatchedKind = 54;
2463             jjmatchedPos = 11;
2464             return 23;
2465          }
2466          if ((active0 & 0x2000000000000L) != 0L)
2467             return 23;
2468          return -1;
2469       case 12:
2470          if ((active0 & 0x4000000000000L) != 0L)
2471          {
2472             jjmatchedKind = 54;
2473             jjmatchedPos = 12;
2474             return 23;
2475          }
2476          return -1;
2477       case 13:
2478          if ((active0 & 0x4000000000000L) != 0L)
2479          {
2480             jjmatchedKind = 54;
2481             jjmatchedPos = 13;
2482             return 23;
2483          }
2484          return -1;
2485       case 14:
2486          if ((active0 & 0x4000000000000L) != 0L)
2487          {
2488             jjmatchedKind = 54;
2489             jjmatchedPos = 14;
2490             return 23;
2491          }
2492          return -1;
2493       case 15:
2494          if ((active0 & 0x4000000000000L) != 0L)
2495          {
2496             jjmatchedKind = 54;
2497             jjmatchedPos = 15;
2498             return 23;
2499          }
2500          return -1;
2501       case 16:
2502          if ((active0 & 0x4000000000000L) != 0L)
2503          {
2504             jjmatchedKind = 54;
2505             jjmatchedPos = 16;
2506             return 23;
2507          }
2508          return -1;
2509       case 17:
2510          if ((active0 & 0x4000000000000L) != 0L)
2511          {
2512             jjmatchedKind = 54;
2513             jjmatchedPos = 17;
2514             return 23;
2515          }
2516          return -1;
2517       case 18:
2518          if ((active0 & 0x4000000000000L) != 0L)
2519          {
2520             jjmatchedKind = 54;
2521             jjmatchedPos = 18;
2522             return 23;
2523          }
2524          return -1;
2525       default :
2526          return -1;
2527    }
2528 }
2529 private static final int jjStartNfa_3(int pos, long active0)
2530 {
2531    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
2532 }
2533 static private final int jjStartNfaWithStates_3(int pos, int kind, int state)
2534 {
2535    jjmatchedKind = kind;
2536    jjmatchedPos = pos;
2537    try { curChar = input_stream.readChar(); }
2538    catch(java.io.IOException e) { return pos + 1; }
2539    return jjMoveNfa_3(state, pos + 1);
2540 }
2541 static private final int jjMoveStringLiteralDfa0_3()
2542 {
2543    switch(curChar)
2544    {
2545       case 33:
2546          return jjStopAtPos(0, 51);
2547       case 40:
2548          return jjStopAtPos(0, 57);
2549       case 41:
2550          return jjStopAtPos(0, 58);
2551       case 44:
2552          return jjStopAtPos(0, 3);
2553       case 46:
2554          return jjStartNfaWithStates_3(0, 4, 5);
2555       case 97:
2556          return jjMoveStringLiteralDfa1_3(0x400000000000L);
2557       case 102:
2558          return jjMoveStringLiteralDfa1_3(0x800000000000L);
2559       case 110:
2560          return jjMoveStringLiteralDfa1_3(0x1000000000000L);
2561       case 112:
2562          return jjMoveStringLiteralDfa1_3(0x1c0000000000L);
2563       case 115:
2564          return jjMoveStringLiteralDfa1_3(0x6200000000000L);
2565       default :
2566          return jjMoveNfa_3(0, 0);
2567    }
2568 }
2569 static private final int jjMoveStringLiteralDfa1_3(long active0)
2570 {
2571    try { curChar = input_stream.readChar(); }
2572    catch(java.io.IOException e) {
2573       jjStopStringLiteralDfa_3(0, active0);
2574       return 1;
2575    }
2576    switch(curChar)
2577    {
2578       case 97:
2579          return jjMoveStringLiteralDfa2_3(active0, 0x1000000000000L);
2580       case 98:
2581          return jjMoveStringLiteralDfa2_3(active0, 0x400000000000L);
2582       case 105:
2583          return jjMoveStringLiteralDfa2_3(active0, 0x800000000000L);
2584       case 114:
2585          return jjMoveStringLiteralDfa2_3(active0, 0x180000000000L);
2586       case 116:
2587          return jjMoveStringLiteralDfa2_3(active0, 0x4200000000000L);
2588       case 117:
2589          return jjMoveStringLiteralDfa2_3(active0, 0x40000000000L);
2590       case 121:
2591          return jjMoveStringLiteralDfa2_3(active0, 0x2000000000000L);
2592       default :
2593          break;
2594    }
2595    return jjStartNfa_3(0, active0);
2596 }
2597 static private final int jjMoveStringLiteralDfa2_3(long old0, long active0)
2598 {
2599    if (((active0 &= old0)) == 0L)
2600       return jjStartNfa_3(0, old0); 
2601    try { curChar = input_stream.readChar(); }
2602    catch(java.io.IOException e) {
2603       jjStopStringLiteralDfa_3(1, active0);
2604       return 2;
2605    }
2606    switch(curChar)
2607    {
2608       case 97:
2609          return jjMoveStringLiteralDfa3_3(active0, 0x4200000000000L);
2610       case 98:
2611          return jjMoveStringLiteralDfa3_3(active0, 0x40000000000L);
2612       case 105:
2613          return jjMoveStringLiteralDfa3_3(active0, 0x100000000000L);
2614       case 110:
2615          return jjMoveStringLiteralDfa3_3(active0, 0x2800000000000L);
2616       case 111:
2617          return jjMoveStringLiteralDfa3_3(active0, 0x80000000000L);
2618       case 115:
2619          return jjMoveStringLiteralDfa3_3(active0, 0x400000000000L);
2620       case 116:
2621          return jjMoveStringLiteralDfa3_3(active0, 0x1000000000000L);
2622       default :
2623          break;
2624    }
2625    return jjStartNfa_3(1, active0);
2626 }
2627 static private final int jjMoveStringLiteralDfa3_3(long old0, long active0)
2628 {
2629    if (((active0 &= old0)) == 0L)
2630       return jjStartNfa_3(1, old0); 
2631    try { curChar = input_stream.readChar(); }
2632    catch(java.io.IOException e) {
2633       jjStopStringLiteralDfa_3(2, active0);
2634       return 3;
2635    }
2636    switch(curChar)
2637    {
2638       case 97:
2639          return jjMoveStringLiteralDfa4_3(active0, 0x800000000000L);
2640       case 99:
2641          return jjMoveStringLiteralDfa4_3(active0, 0x2000000000000L);
2642       case 105:
2643          return jjMoveStringLiteralDfa4_3(active0, 0x1000000000000L);
2644       case 108:
2645          return jjMoveStringLiteralDfa4_3(active0, 0x40000000000L);
2646       case 116:
2647          return jjMoveStringLiteralDfa4_3(active0, 0x4680000000000L);
2648       case 118:
2649          return jjMoveStringLiteralDfa4_3(active0, 0x100000000000L);
2650       default :
2651          break;
2652    }
2653    return jjStartNfa_3(2, active0);
2654 }
2655 static private final int jjMoveStringLiteralDfa4_3(long old0, long active0)
2656 {
2657    if (((active0 &= old0)) == 0L)
2658       return jjStartNfa_3(2, old0); 
2659    try { curChar = input_stream.readChar(); }
2660    catch(java.io.IOException e) {
2661       jjStopStringLiteralDfa_3(3, active0);
2662       return 4;
2663    }
2664    switch(curChar)
2665    {
2666       case 97:
2667          return jjMoveStringLiteralDfa5_3(active0, 0x100000000000L);
2668       case 101:
2669          return jjMoveStringLiteralDfa5_3(active0, 0x80000000000L);
2670       case 104:
2671          return jjMoveStringLiteralDfa5_3(active0, 0x2000000000000L);
2672       case 105:
2673          return jjMoveStringLiteralDfa5_3(active0, 0x4240000000000L);
2674       case 108:
2675          if ((active0 & 0x800000000000L) != 0L)
2676             return jjStartNfaWithStates_3(4, 47, 23);
2677          break;
2678       case 114:
2679          return jjMoveStringLiteralDfa5_3(active0, 0x400000000000L);
2680       case 118:
2681          return jjMoveStringLiteralDfa5_3(active0, 0x1000000000000L);
2682       default :
2683          break;
2684    }
2685    return jjStartNfa_3(3, active0);
2686 }
2687 static private final int jjMoveStringLiteralDfa5_3(long old0, long active0)
2688 {
2689    if (((active0 &= old0)) == 0L)
2690       return jjStartNfa_3(3, old0); 
2691    try { curChar = input_stream.readChar(); }
2692    catch(java.io.IOException e) {
2693       jjStopStringLiteralDfa_3(4, active0);
2694       return 5;
2695    }
2696    switch(curChar)
2697    {
2698       case 97:
2699          return jjMoveStringLiteralDfa6_3(active0, 0x400000000000L);
2700       case 99:
2701          if ((active0 & 0x40000000000L) != 0L)
2702             return jjStartNfaWithStates_3(5, 42, 23);
2703          else if ((active0 & 0x200000000000L) != 0L)
2704          {
2705             jjmatchedKind = 45;
2706             jjmatchedPos = 5;
2707          }
2708          return jjMoveStringLiteralDfa6_3(active0, 0x4080000000000L);
2709       case 101:
2710          if ((active0 & 0x1000000000000L) != 0L)
2711             return jjStartNfaWithStates_3(5, 48, 23);
2712          break;
2713       case 114:
2714          return jjMoveStringLiteralDfa6_3(active0, 0x2000000000000L);
2715       case 116:
2716          return jjMoveStringLiteralDfa6_3(active0, 0x100000000000L);
2717       default :
2718          break;
2719    }
2720    return jjStartNfa_3(4, active0);
2721 }
2722 static private final int jjMoveStringLiteralDfa6_3(long old0, long active0)
2723 {
2724    if (((active0 &= old0)) == 0L)
2725       return jjStartNfa_3(4, old0); 
2726    try { curChar = input_stream.readChar(); }
2727    catch(java.io.IOException e) {
2728       jjStopStringLiteralDfa_3(5, active0);
2729       return 6;
2730    }
2731    switch(curChar)
2732    {
2733       case 99:
2734          return jjMoveStringLiteralDfa7_3(active0, 0x400000000000L);
2735       case 101:
2736          if ((active0 & 0x100000000000L) != 0L)
2737             return jjStartNfaWithStates_3(6, 44, 23);
2738          break;
2739       case 105:
2740          return jjMoveStringLiteralDfa7_3(active0, 0x4000000000000L);
2741       case 111:
2742          return jjMoveStringLiteralDfa7_3(active0, 0x2000000000000L);
2743       case 116:
2744          return jjMoveStringLiteralDfa7_3(active0, 0x80000000000L);
2745       default :
2746          break;
2747    }
2748    return jjStartNfa_3(5, active0);
2749 }
2750 static private final int jjMoveStringLiteralDfa7_3(long old0, long active0)
2751 {
2752    if (((active0 &= old0)) == 0L)
2753       return jjStartNfa_3(5, old0); 
2754    try { curChar = input_stream.readChar(); }
2755    catch(java.io.IOException e) {
2756       jjStopStringLiteralDfa_3(6, active0);
2757       return 7;
2758    }
2759    switch(curChar)
2760    {
2761       case 101:
2762          return jjMoveStringLiteralDfa8_3(active0, 0x80000000000L);
2763       case 110:
2764          return jjMoveStringLiteralDfa8_3(active0, 0x6000000000000L);
2765       case 116:
2766          if ((active0 & 0x400000000000L) != 0L)
2767             return jjStartNfaWithStates_3(7, 46, 23);
2768          break;
2769       default :
2770          break;
2771    }
2772    return jjStartNfa_3(6, active0);
2773 }
2774 static private final int jjMoveStringLiteralDfa8_3(long old0, long active0)
2775 {
2776    if (((active0 &= old0)) == 0L)
2777       return jjStartNfa_3(6, old0); 
2778    try { curChar = input_stream.readChar(); }
2779    catch(java.io.IOException e) {
2780       jjStopStringLiteralDfa_3(7, active0);
2781       return 8;
2782    }
2783    switch(curChar)
2784    {
2785       case 100:
2786          if ((active0 & 0x80000000000L) != 0L)
2787             return jjStartNfaWithStates_3(8, 43, 23);
2788          break;
2789       case 105:
2790          return jjMoveStringLiteralDfa9_3(active0, 0x6000000000000L);
2791       default :
2792          break;
2793    }
2794    return jjStartNfa_3(7, active0);
2795 }
2796 static private final int jjMoveStringLiteralDfa9_3(long old0, long active0)
2797 {
2798    if (((active0 &= old0)) == 0L)
2799       return jjStartNfa_3(7, old0); 
2800    try { curChar = input_stream.readChar(); }
2801    catch(java.io.IOException e) {
2802       jjStopStringLiteralDfa_3(8, active0);
2803       return 9;
2804    }
2805    switch(curChar)
2806    {
2807       case 116:
2808          return jjMoveStringLiteralDfa10_3(active0, 0x4000000000000L);
2809       case 122:
2810          return jjMoveStringLiteralDfa10_3(active0, 0x2000000000000L);
2811       default :
2812          break;
2813    }
2814    return jjStartNfa_3(8, active0);
2815 }
2816 static private final int jjMoveStringLiteralDfa10_3(long old0, long active0)
2817 {
2818    if (((active0 &= old0)) == 0L)
2819       return jjStartNfa_3(8, old0); 
2820    try { curChar = input_stream.readChar(); }
2821    catch(java.io.IOException e) {
2822       jjStopStringLiteralDfa_3(9, active0);
2823       return 10;
2824    }
2825    switch(curChar)
2826    {
2827       case 101:
2828          return jjMoveStringLiteralDfa11_3(active0, 0x2000000000000L);
2829       case 105:
2830          return jjMoveStringLiteralDfa11_3(active0, 0x4000000000000L);
2831       default :
2832          break;
2833    }
2834    return jjStartNfa_3(9, active0);
2835 }
2836 static private final int jjMoveStringLiteralDfa11_3(long old0, long active0)
2837 {
2838    if (((active0 &= old0)) == 0L)
2839       return jjStartNfa_3(9, old0); 
2840    try { curChar = input_stream.readChar(); }
2841    catch(java.io.IOException e) {
2842       jjStopStringLiteralDfa_3(10, active0);
2843       return 11;
2844    }
2845    switch(curChar)
2846    {
2847       case 97:
2848          return jjMoveStringLiteralDfa12_3(active0, 0x4000000000000L);
2849       case 100:
2850          if ((active0 & 0x2000000000000L) != 0L)
2851             return jjStartNfaWithStates_3(11, 49, 23);
2852          break;
2853       default :
2854          break;
2855    }
2856    return jjStartNfa_3(10, active0);
2857 }
2858 static private final int jjMoveStringLiteralDfa12_3(long old0, long active0)
2859 {
2860    if (((active0 &= old0)) == 0L)
2861       return jjStartNfa_3(10, old0); 
2862    try { curChar = input_stream.readChar(); }
2863    catch(java.io.IOException e) {
2864       jjStopStringLiteralDfa_3(11, active0);
2865       return 12;
2866    }
2867    switch(curChar)
2868    {
2869       case 108:
2870          return jjMoveStringLiteralDfa13_3(active0, 0x4000000000000L);
2871       default :
2872          break;
2873    }
2874    return jjStartNfa_3(11, active0);
2875 }
2876 static private final int jjMoveStringLiteralDfa13_3(long old0, long active0)
2877 {
2878    if (((active0 &= old0)) == 0L)
2879       return jjStartNfa_3(11, old0); 
2880    try { curChar = input_stream.readChar(); }
2881    catch(java.io.IOException e) {
2882       jjStopStringLiteralDfa_3(12, active0);
2883       return 13;
2884    }
2885    switch(curChar)
2886    {
2887       case 105:
2888          return jjMoveStringLiteralDfa14_3(active0, 0x4000000000000L);
2889       default :
2890          break;
2891    }
2892    return jjStartNfa_3(12, active0);
2893 }
2894 static private final int jjMoveStringLiteralDfa14_3(long old0, long active0)
2895 {
2896    if (((active0 &= old0)) == 0L)
2897       return jjStartNfa_3(12, old0); 
2898    try { curChar = input_stream.readChar(); }
2899    catch(java.io.IOException e) {
2900       jjStopStringLiteralDfa_3(13, active0);
2901       return 14;
2902    }
2903    switch(curChar)
2904    {
2905       case 122:
2906          return jjMoveStringLiteralDfa15_3(active0, 0x4000000000000L);
2907       default :
2908          break;
2909    }
2910    return jjStartNfa_3(13, active0);
2911 }
2912 static private final int jjMoveStringLiteralDfa15_3(long old0, long active0)
2913 {
2914    if (((active0 &= old0)) == 0L)
2915       return jjStartNfa_3(13, old0); 
2916    try { curChar = input_stream.readChar(); }
2917    catch(java.io.IOException e) {
2918       jjStopStringLiteralDfa_3(14, active0);
2919       return 15;
2920    }
2921    switch(curChar)
2922    {
2923       case 97:
2924          return jjMoveStringLiteralDfa16_3(active0, 0x4000000000000L);
2925       default :
2926          break;
2927    }
2928    return jjStartNfa_3(14, active0);
2929 }
2930 static private final int jjMoveStringLiteralDfa16_3(long old0, long active0)
2931 {
2932    if (((active0 &= old0)) == 0L)
2933       return jjStartNfa_3(14, old0); 
2934    try { curChar = input_stream.readChar(); }
2935    catch(java.io.IOException e) {
2936       jjStopStringLiteralDfa_3(15, active0);
2937       return 16;
2938    }
2939    switch(curChar)
2940    {
2941       case 116:
2942          return jjMoveStringLiteralDfa17_3(active0, 0x4000000000000L);
2943       default :
2944          break;
2945    }
2946    return jjStartNfa_3(15, active0);
2947 }
2948 static private final int jjMoveStringLiteralDfa17_3(long old0, long active0)
2949 {
2950    if (((active0 &= old0)) == 0L)
2951       return jjStartNfa_3(15, old0); 
2952    try { curChar = input_stream.readChar(); }
2953    catch(java.io.IOException e) {
2954       jjStopStringLiteralDfa_3(16, active0);
2955       return 17;
2956    }
2957    switch(curChar)
2958    {
2959       case 105:
2960          return jjMoveStringLiteralDfa18_3(active0, 0x4000000000000L);
2961       default :
2962          break;
2963    }
2964    return jjStartNfa_3(16, active0);
2965 }
2966 static private final int jjMoveStringLiteralDfa18_3(long old0, long active0)
2967 {
2968    if (((active0 &= old0)) == 0L)
2969       return jjStartNfa_3(16, old0); 
2970    try { curChar = input_stream.readChar(); }
2971    catch(java.io.IOException e) {
2972       jjStopStringLiteralDfa_3(17, active0);
2973       return 18;
2974    }
2975    switch(curChar)
2976    {
2977       case 111:
2978          return jjMoveStringLiteralDfa19_3(active0, 0x4000000000000L);
2979       default :
2980          break;
2981    }
2982    return jjStartNfa_3(17, active0);
2983 }
2984 static private final int jjMoveStringLiteralDfa19_3(long old0, long active0)
2985 {
2986    if (((active0 &= old0)) == 0L)
2987       return jjStartNfa_3(17, old0); 
2988    try { curChar = input_stream.readChar(); }
2989    catch(java.io.IOException e) {
2990       jjStopStringLiteralDfa_3(18, active0);
2991       return 19;
2992    }
2993    switch(curChar)
2994    {
2995       case 110:
2996          if ((active0 & 0x4000000000000L) != 0L)
2997             return jjStartNfaWithStates_3(19, 50, 23);
2998          break;
2999       default :
3000          break;
3001    }
3002    return jjStartNfa_3(18, active0);
3003 }
3004 static private final int jjMoveNfa_3(int startState, int curPos)
3005 {
3006    int[] nextStates;
3007    int startsAt = 0;
3008    jjnewStateCnt = 23;
3009    int i = 1;
3010    jjstateSet[0] = startState;
3011    int j, kind = 0x7fffffff;
3012    for (;;)
3013    {
3014       if (++jjround == 0x7fffffff)
3015          ReInitRounds();
3016       if (curChar < 64)
3017       {
3018          long l = 1L << curChar;
3019          MatchLoop: do
3020          {
3021             switch(jjstateSet[--i])
3022             {
3023                case 5:
3024                   if (curChar == 46)
3025                      jjCheckNAddStates(22, 24);
3026                   if (curChar == 46)
3027                   {
3028                      if (kind > 54)
3029                         kind = 54;
3030                      jjCheckNAddTwoStates(7, 8);
3031                   }
3032                   if (curChar == 46)
3033                   {
3034                      if (kind > 7)
3035                         kind = 7;
3036                   }
3037                   break;
3038                case 23:
3039                   if ((0x3ff0c1800000000L & l) != 0L)
3040                      jjCheckNAddStates(22, 24);
3041                   else if (curChar == 46)
3042                      jjCheckNAddStates(25, 27);
3043                   if ((0x3ff0c1800000000L & l) != 0L)
3044                   {
3045                      if (kind > 54)
3046                         kind = 54;
3047                      jjCheckNAddTwoStates(7, 8);
3048                   }
3049                   else if (curChar == 46)
3050                      jjCheckNAddStates(28, 30);
3051                   break;
3052                case 0:
3053                   if ((0x3ff0c1800000000L & l) != 0L)
3054                   {
3055                      if (kind > 54)
3056                         kind = 54;
3057                      jjCheckNAddStates(31, 35);
3058                   }
3059                   else if (curChar == 46)
3060                      jjCheckNAddStates(36, 38);
3061                   break;
3062                case 1:
3063                   if ((0x3ff081800000000L & l) == 0L)
3064                      break;
3065                   if (kind > 52)
3066                      kind = 52;
3067                   jjCheckNAddTwoStates(1, 2);
3068                   break;
3069                case 2:
3070                   if (curChar == 46)
3071                      jjCheckNAdd(3);
3072                   break;
3073                case 3:
3074                   if ((0x3ff081800000000L & l) == 0L)
3075                      break;
3076                   if (kind > 52)
3077                      kind = 52;
3078                   jjCheckNAddTwoStates(2, 3);
3079                   break;
3080                case 4:
3081                   if (curChar == 46)
3082                      jjCheckNAddStates(36, 38);
3083                   break;
3084                case 6:
3085                   if (curChar != 46)
3086                      break;
3087                   if (kind > 54)
3088                      kind = 54;
3089                   jjCheckNAddTwoStates(7, 8);
3090                   break;
3091                case 7:
3092                   if ((0x3ff0c1800000000L & l) == 0L)
3093                      break;
3094                   if (kind > 54)
3095                      kind = 54;
3096                   jjCheckNAddTwoStates(7, 8);
3097                   break;
3098                case 8:
3099                   if (curChar == 46)
3100                      jjCheckNAddStates(25, 27);
3101                   break;
3102                case 9:
3103                   if ((0x3ff0c1800000000L & l) == 0L)
3104                      break;
3105                   if (kind > 54)
3106                      kind = 54;
3107                   jjCheckNAddTwoStates(9, 10);
3108                   break;
3109                case 10:
3110                   if (curChar == 46)
3111                      jjCheckNAddStates(39, 41);
3112                   break;
3113                case 11:
3114                   if (curChar == 46)
3115                      jjCheckNAdd(12);
3116                   break;
3117                case 12:
3118                   if (curChar != 46)
3119                      break;
3120                   if (kind > 54)
3121                      kind = 54;
3122                   jjCheckNAddTwoStates(9, 10);
3123                   break;
3124                case 13:
3125                   if (curChar == 46)
3126                      jjCheckNAddStates(22, 24);
3127                   break;
3128                case 14:
3129                   if ((0x3ff0c1800000000L & l) != 0L)
3130                      jjCheckNAddStates(22, 24);
3131                   break;
3132                case 17:
3133                   if (curChar == 46)
3134                      jjCheckNAddStates(28, 30);
3135                   break;
3136                case 18:
3137                   if ((0x3ff0c1800000000L & l) != 0L)
3138                      jjCheckNAddStates(42, 44);
3139                   break;
3140                case 19:
3141                   if (curChar == 46)
3142                      jjCheckNAddStates(45, 47);
3143                   break;
3144                case 20:
3145                   if (curChar == 46)
3146                      jjCheckNAdd(21);
3147                   break;
3148                case 21:
3149                   if (curChar == 46)
3150                      jjCheckNAddStates(42, 44);
3151                   break;
3152                case 22:
3153                   if ((0x3ff0c1800000000L & l) == 0L)
3154                      break;
3155                   if (kind > 54)
3156                      kind = 54;
3157                   jjCheckNAddStates(31, 35);
3158                   break;
3159                default : break;
3160             }
3161          } while(i != startsAt);
3162       }
3163       else if (curChar < 128)
3164       {
3165          long l = 1L << (curChar & 077);
3166          MatchLoop: do
3167          {
3168             switch(jjstateSet[--i])
3169             {
3170                case 23:
3171                   if ((0x7fffffe87fffffeL & l) != 0L)
3172                      jjCheckNAddStates(22, 24);
3173                   else if (curChar == 91)
3174                      jjstateSet[jjnewStateCnt++] = 15;
3175                   if ((0x7fffffe87fffffeL & l) != 0L)
3176                   {
3177                      if (kind > 54)
3178                         kind = 54;
3179                      jjCheckNAddTwoStates(7, 8);
3180                   }
3181                   break;
3182                case 0:
3183                   if ((0x7fffffe87fffffeL & l) != 0L)
3184                   {
3185                      if (kind > 54)
3186                         kind = 54;
3187                      jjCheckNAddStates(31, 35);
3188                   }
3189                   else if (curChar == 64)
3190                      jjCheckNAdd(1);
3191                   break;
3192                case 1:
3193                   if ((0x7fffffe87fffffeL & l) == 0L)
3194                      break;
3195                   if (kind > 52)
3196                      kind = 52;
3197                   jjCheckNAddTwoStates(1, 2);
3198                   break;
3199                case 3:
3200                   if ((0x7fffffe87fffffeL & l) == 0L)
3201                      break;
3202                   if (kind > 52)
3203                      kind = 52;
3204                   jjCheckNAddTwoStates(2, 3);
3205                   break;
3206                case 7:
3207                   if ((0x7fffffe87fffffeL & l) == 0L)
3208                      break;
3209                   if (kind > 54)
3210                      kind = 54;
3211                   jjCheckNAddTwoStates(7, 8);
3212                   break;
3213                case 9:
3214                   if ((0x7fffffe87fffffeL & l) == 0L)
3215                      break;
3216                   if (kind > 54)
3217                      kind = 54;
3218                   jjAddStates(48, 49);
3219                   break;
3220                case 14:
3221                   if ((0x7fffffe87fffffeL & l) != 0L)
3222                      jjCheckNAddStates(22, 24);
3223                   break;
3224                case 15:
3225                   if (curChar != 93)
3226                      break;
3227                   kind = 55;
3228                   jjCheckNAdd(16);
3229                   break;
3230                case 16:
3231                   if (curChar == 91)
3232                      jjstateSet[jjnewStateCnt++] = 15;
3233                   break;
3234                case 18:
3235                   if ((0x7fffffe87fffffeL & l) != 0L)
3236                      jjCheckNAddStates(42, 44);
3237                   break;
3238                case 22:
3239                   if ((0x7fffffe87fffffeL & l) == 0L)
3240                      break;
3241                   if (kind > 54)
3242                      kind = 54;
3243                   jjCheckNAddStates(31, 35);
3244                   break;
3245                default : break;
3246             }
3247          } while(i != startsAt);
3248       }
3249       else
3250       {
3251          int i2 = (curChar & 0xff) >> 6;
3252          long l2 = 1L << (curChar & 077);
3253          MatchLoop: do
3254          {
3255             switch(jjstateSet[--i])
3256             {
3257                default : break;
3258             }
3259          } while(i != startsAt);
3260       }
3261       if (kind != 0x7fffffff)
3262       {
3263          jjmatchedKind = kind;
3264          jjmatchedPos = curPos;
3265          kind = 0x7fffffff;
3266       }
3267       ++curPos;
3268       if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
3269          return curPos;
3270       try { curChar = input_stream.readChar(); }
3271       catch(java.io.IOException e) { return curPos; }
3272    }
3273 }
3274 private static final int jjStopStringLiteralDfa_1(int pos, long active0, long active1)
3275 {
3276    switch (pos)
3277    {
3278       default :
3279          return -1;
3280    }
3281 }
3282 private static final int jjStartNfa_1(int pos, long active0, long active1)
3283 {
3284    return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0, active1), pos + 1);
3285 }
3286 static private final int jjStartNfaWithStates_1(int pos, int kind, int state)
3287 {
3288    jjmatchedKind = kind;
3289    jjmatchedPos = pos;
3290    try { curChar = input_stream.readChar(); }
3291    catch(java.io.IOException e) { return pos + 1; }
3292    return jjMoveNfa_1(state, pos + 1);
3293 }
3294 static private final int jjMoveStringLiteralDfa0_1()
3295 {
3296    switch(curChar)
3297    {
3298       case 33:
3299          return jjStopAtPos(0, 80);
3300       case 44:
3301          return jjStopAtPos(0, 3);
3302       case 46:
3303          return jjStartNfaWithStates_1(0, 4, 5);
3304       default :
3305          return jjMoveNfa_1(0, 0);
3306    }
3307 }
3308 static private final int jjMoveNfa_1(int startState, int curPos)
3309 {
3310    int[] nextStates;
3311    int startsAt = 0;
3312    jjnewStateCnt = 23;
3313    int i = 1;
3314    jjstateSet[0] = startState;
3315    int j, kind = 0x7fffffff;
3316    for (;;)
3317    {
3318       if (++jjround == 0x7fffffff)
3319          ReInitRounds();
3320       if (curChar < 64)
3321       {
3322          long l = 1L << curChar;
3323          MatchLoop: do
3324          {
3325             switch(jjstateSet[--i])
3326             {
3327                case 5:
3328                   if (curChar == 46)
3329                      jjCheckNAddStates(22, 24);
3330                   if (curChar == 46)
3331                   {
3332                      if (kind > 76)
3333                         kind = 76;
3334                      jjCheckNAddTwoStates(7, 8);
3335                   }
3336                   if (curChar == 46)
3337                   {
3338                      if (kind > 7)
3339                         kind = 7;
3340                   }
3341                   break;
3342                case 0:
3343                   if ((0x3ff0c1800000000L & l) != 0L)
3344                   {
3345                      if (kind > 76)
3346                         kind = 76;
3347                      jjCheckNAddStates(31, 35);
3348                   }
3349                   else if (curChar == 46)
3350                      jjCheckNAddStates(36, 38);
3351                   break;
3352                case 1:
3353                   if ((0x3ff0c1800000000L & l) == 0L)
3354                      break;
3355                   if (kind > 78)
3356                      kind = 78;
3357                   jjCheckNAddTwoStates(1, 2);
3358                   break;
3359                case 2:
3360                   if (curChar == 46)
3361                      jjstateSet[jjnewStateCnt++] = 3;
3362                   break;
3363                case 3:
3364                   if (curChar != 46)
3365                      break;
3366                   if (kind > 78)
3367                      kind = 78;
3368                   jjCheckNAddTwoStates(1, 2);
3369                   break;
3370                case 4:
3371                   if (curChar == 46)
3372                      jjCheckNAddStates(36, 38);
3373                   break;
3374                case 6:
3375                   if (curChar != 46)
3376                      break;
3377                   if (kind > 76)
3378                      kind = 76;
3379                   jjCheckNAddTwoStates(7, 8);
3380                   break;
3381                case 7:
3382                   if ((0x3ff0c1800000000L & l) == 0L)
3383                      break;
3384                   if (kind > 76)
3385                      kind = 76;
3386                   jjCheckNAddTwoStates(7, 8);
3387                   break;
3388                case 8:
3389                   if (curChar == 46)
3390                      jjCheckNAddStates(25, 27);
3391                   break;
3392                case 9:
3393                   if ((0x3ff0c1800000000L & l) == 0L)
3394                      break;
3395                   if (kind > 76)
3396                      kind = 76;
3397                   jjCheckNAddTwoStates(9, 10);
3398                   break;
3399                case 10:
3400                   if (curChar == 46)
3401                      jjCheckNAddStates(39, 41);
3402                   break;
3403                case 11:
3404                   if (curChar == 46)
3405                      jjCheckNAdd(12);
3406                   break;
3407                case 12:
3408                   if (curChar != 46)
3409                      break;
3410                   if (kind > 76)
3411                      kind = 76;
3412                   jjCheckNAddTwoStates(9, 10);
3413                   break;
3414                case 13:
3415                   if (curChar == 46)
3416                      jjCheckNAddStates(22, 24);
3417                   break;
3418                case 14:
3419                   if ((0x3ff0c1800000000L & l) != 0L)
3420                      jjCheckNAddStates(22, 24);
3421                   break;
3422                case 17:
3423                   if (curChar == 46)
3424                      jjCheckNAddStates(28, 30);
3425                   break;
3426                case 18:
3427                   if ((0x3ff0c1800000000L & l) != 0L)
3428                      jjCheckNAddStates(42, 44);
3429                   break;
3430                case 19:
3431                   if (curChar == 46)
3432                      jjCheckNAddStates(45, 47);
3433                   break;
3434                case 20:
3435                   if (curChar == 46)
3436                      jjCheckNAdd(21);
3437                   break;
3438                case 21:
3439                   if (curChar == 46)
3440                      jjCheckNAddStates(42, 44);
3441                   break;
3442                case 22:
3443                   if ((0x3ff0c1800000000L & l) == 0L)
3444                      break;
3445                   if (kind > 76)
3446                      kind = 76;
3447                   jjCheckNAddStates(31, 35);
3448                   break;
3449                default : break;
3450             }
3451          } while(i != startsAt);
3452       }
3453       else if (curChar < 128)
3454       {
3455          long l = 1L << (curChar & 077);
3456          MatchLoop: do
3457          {
3458             switch(jjstateSet[--i])
3459             {
3460                case 0:
3461                   if ((0x7fffffe87fffffeL & l) != 0L)
3462                   {
3463                      if (kind > 76)
3464                         kind = 76;
3465                      jjCheckNAddStates(31, 35);
3466                   }
3467                   else if (curChar == 64)
3468                      jjCheckNAddTwoStates(1, 2);
3469                   break;
3470                case 1:
3471                   if ((0x7fffffe87fffffeL & l) == 0L)
3472                      break;
3473                   if (kind > 78)
3474                      kind = 78;
3475                   jjCheckNAddTwoStates(1, 2);
3476                   break;
3477                case 7:
3478                   if ((0x7fffffe87fffffeL & l) == 0L)
3479                      break;
3480                   if (kind > 76)
3481                      kind = 76;
3482                   jjCheckNAddTwoStates(7, 8);
3483                   break;
3484                case 9:
3485                   if ((0x7fffffe87fffffeL & l) == 0L)
3486                      break;
3487                   if (kind > 76)
3488                      kind = 76;
3489                   jjAddStates(48, 49);
3490                   break;
3491                case 14:
3492                   if ((0x7fffffe87fffffeL & l) != 0L)
3493                      jjCheckNAddStates(22, 24);
3494                   break;
3495                case 15:
3496                   if (curChar != 93)
3497                      break;
3498                   kind = 77;
3499                   jjCheckNAdd(16);
3500                   break;
3501                case 16:
3502                   if (curChar == 91)
3503                      jjstateSet[jjnewStateCnt++] = 15;
3504                   break;
3505                case 18:
3506                   if ((0x7fffffe87fffffeL & l) != 0L)
3507                      jjCheckNAddStates(42, 44);
3508                   break;
3509                case 22:
3510                   if ((0x7fffffe87fffffeL & l) == 0L)
3511                      break;
3512                   if (kind > 76)
3513                      kind = 76;
3514                   jjCheckNAddStates(31, 35);
3515                   break;
3516                default : break;
3517             }
3518          } while(i != startsAt);
3519       }
3520       else
3521       {
3522          int i2 = (curChar & 0xff) >> 6;
3523          long l2 = 1L << (curChar & 077);
3524          MatchLoop: do
3525          {
3526             switch(jjstateSet[--i])
3527             {
3528                default : break;
3529             }
3530          } while(i != startsAt);
3531       }
3532       if (kind != 0x7fffffff)
3533       {
3534          jjmatchedKind = kind;
3535          jjmatchedPos = curPos;
3536          kind = 0x7fffffff;
3537       }
3538       ++curPos;
3539       if ((i = jjnewStateCnt) == (startsAt = 23 - (jjnewStateCnt = startsAt)))
3540          return curPos;
3541       try { curChar = input_stream.readChar(); }
3542       catch(java.io.IOException e) { return curPos; }
3543    }
3544 }
3545 static final int[] jjnextStates = {
3546    19, 20, 21, 3, 4, 6, 7, 10, 6, 7, 10, 7, 8, 10, 6, 7, 
3547    9, 7, 9, 10, 7, 8, 14, 16, 17, 6, 9, 11, 13, 18, 20, 7, 
3548    14, 16, 17, 8, 5, 6, 13, 9, 11, 12, 18, 16, 19, 18, 20, 21, 
3549    9, 10, 
3550 };
3551 public static final String[] jjstrLiteralImages = {
3552 "", null, null, "\54", "\56", null, null, null, null, null, "\41", 
3553 "\145\170\145\143\165\164\151\157\156\50", "\143\141\154\154\50", "\163\145\164\50", "\147\145\164\50", 
3554 "\150\141\156\144\154\145\162\50", "\167\151\164\150\151\156\50", "\167\151\164\150\151\156\143\157\144\145\50", 
3555 "\163\164\141\164\151\143\151\156\151\164\151\141\154\151\172\141\164\151\157\156\50", "\143\146\154\157\167\50", "\143\146\154\157\167\142\145\154\157\167\50", 
3556 "\141\162\147\163\50", "\164\141\162\147\145\164\50", "\164\150\151\163\50", "\151\146\50", 
3557 "\150\141\163\155\145\164\150\157\144\50", "\150\141\163\146\151\145\154\144\50", null, null, 
3558 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 
3559 "\163\164\141\164\151\143", "\141\142\163\164\162\141\143\164", "\146\151\156\141\154", "\41", null, null, 
3560 null, null, null, "\51", "\160\165\142\154\151\143", 
3561 "\160\162\157\164\145\143\164\145\144", "\160\162\151\166\141\164\145", "\163\164\141\164\151\143", 
3562 "\141\142\163\164\162\141\143\164", "\146\151\156\141\154", "\156\141\164\151\166\145", 
3563 "\163\171\156\143\150\162\157\156\151\172\145\144", 
3564 "\163\164\141\164\151\143\151\156\151\164\151\141\154\151\172\141\164\151\157\156", "\41", null, null, null, null, null, "\50", "\51", null, 
3565 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 
3566 "\163\164\141\164\151\143", "\141\142\163\164\162\141\143\164", "\146\151\156\141\154", 
3567 "\164\162\141\156\163\151\145\156\164", "\41", null, null, null, null, null, null, "\51", null, null, null, null, null, 
3568 "\41", null, null, null, null, "\51", "\50", "\51", };
3569 public static final String[] lexStateNames = {
3570    "IN_ARGS", 
3571    "PARAMETERS", 
3572    "FIELD", 
3573    "METHOD", 
3574    "CLASS", 
3575    "DEFAULT", 
3576 };
3577 public static final int[] jjnewLexState = {
3578    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 3, 2, 2, 4, 4, 3, 4, -1, -1, 0, 4, 4, -1, 
3579    3, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, 
3580    -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, 
3581    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, 
3582 };
3583 static final long[] jjtoToken = {
3584    0xf6dffe3fffffff99L, 0xed74dfL, 
3585 };
3586 static final long[] jjtoSkip = {
3587    0x6L, 0x0L, 
3588 };
3589 static protected SimpleCharStream input_stream;
3590 static private final int[] jjrounds = new int[23];
3591 static private final int[] jjstateSet = new int[46];
3592 static protected char curChar;
3593 public ExpressionParserTokenManager(SimpleCharStream stream)
3594 {
3595    if (input_stream != null)
3596       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);
3597    input_stream = stream;
3598 }
3599 public ExpressionParserTokenManager(SimpleCharStream stream, int lexState)
3600 {
3601    this(stream);
3602    SwitchTo(lexState);
3603 }
3604 static public void ReInit(SimpleCharStream stream)
3605 {
3606    jjmatchedPos = jjnewStateCnt = 0;
3607    curLexState = defaultLexState;
3608    input_stream = stream;
3609    ReInitRounds();
3610 }
3611 static private final void ReInitRounds()
3612 {
3613    int i;
3614    jjround = 0x80000001;
3615    for (i = 23; i-- > 0;)
3616       jjrounds[i] = 0x80000000;
3617 }
3618 static public void ReInit(SimpleCharStream stream, int lexState)
3619 {
3620    ReInit(stream);
3621    SwitchTo(lexState);
3622 }
3623 static public void SwitchTo(int lexState)
3624 {
3625    if (lexState >= 6 || lexState < 0)
3626       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
3627    else
3628       curLexState = lexState;
3629 }
3630 
3631 static protected Token jjFillToken()
3632 {
3633    Token t = Token.newToken(jjmatchedKind);
3634    t.kind = jjmatchedKind;
3635    String im = jjstrLiteralImages[jjmatchedKind];
3636    t.image = (im == null) ? input_stream.GetImage() : im;
3637    t.beginLine = input_stream.getBeginLine();
3638    t.beginColumn = input_stream.getBeginColumn();
3639    t.endLine = input_stream.getEndLine();
3640    t.endColumn = input_stream.getEndColumn();
3641    return t;
3642 }
3643 
3644 static int curLexState = 5;
3645 static int defaultLexState = 5;
3646 static int jjnewStateCnt;
3647 static int jjround;
3648 static int jjmatchedPos;
3649 static int jjmatchedKind;
3650 
3651 public static Token getNextToken() 
3652 {
3653   int kind;
3654   Token specialToken = null;
3655   Token matchedToken;
3656   int curPos = 0;
3657 
3658   EOFLoop :
3659   for (;;)
3660   {   
3661    try   
3662    {     
3663       curChar = input_stream.BeginToken();
3664    }     
3665    catch(java.io.IOException e)
3666    {        
3667       jjmatchedKind = 0;
3668       matchedToken = jjFillToken();
3669       return matchedToken;
3670    }
3671 
3672    switch(curLexState)
3673    {
3674      case 0:
3675        try { input_stream.backup(0);
3676           while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3677              curChar = input_stream.BeginToken();
3678        }
3679        catch (java.io.IOException e1) { continue EOFLoop; }
3680        jjmatchedKind = 0x7fffffff;
3681        jjmatchedPos = 0;
3682        curPos = jjMoveStringLiteralDfa0_0();
3683        break;
3684      case 1:
3685        try { input_stream.backup(0);
3686           while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3687              curChar = input_stream.BeginToken();
3688        }
3689        catch (java.io.IOException e1) { continue EOFLoop; }
3690        jjmatchedKind = 0x7fffffff;
3691        jjmatchedPos = 0;
3692        curPos = jjMoveStringLiteralDfa0_1();
3693        break;
3694      case 2:
3695        try { input_stream.backup(0);
3696           while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3697              curChar = input_stream.BeginToken();
3698        }
3699        catch (java.io.IOException e1) { continue EOFLoop; }
3700        jjmatchedKind = 0x7fffffff;
3701        jjmatchedPos = 0;
3702        curPos = jjMoveStringLiteralDfa0_2();
3703        break;
3704      case 3:
3705        try { input_stream.backup(0);
3706           while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3707              curChar = input_stream.BeginToken();
3708        }
3709        catch (java.io.IOException e1) { continue EOFLoop; }
3710        jjmatchedKind = 0x7fffffff;
3711        jjmatchedPos = 0;
3712        curPos = jjMoveStringLiteralDfa0_3();
3713        break;
3714      case 4:
3715        try { input_stream.backup(0);
3716           while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3717              curChar = input_stream.BeginToken();
3718        }
3719        catch (java.io.IOException e1) { continue EOFLoop; }
3720        jjmatchedKind = 0x7fffffff;
3721        jjmatchedPos = 0;
3722        curPos = jjMoveStringLiteralDfa0_4();
3723        break;
3724      case 5:
3725        try { input_stream.backup(0);
3726           while (curChar <= 32 && (0x100000200L & (1L << curChar)) != 0L)
3727              curChar = input_stream.BeginToken();
3728        }
3729        catch (java.io.IOException e1) { continue EOFLoop; }
3730        jjmatchedKind = 0x7fffffff;
3731        jjmatchedPos = 0;
3732        curPos = jjMoveStringLiteralDfa0_5();
3733        break;
3734    }
3735      if (jjmatchedKind != 0x7fffffff)
3736      {
3737         if (jjmatchedPos + 1 < curPos)
3738            input_stream.backup(curPos - jjmatchedPos - 1);
3739         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
3740         {
3741            matchedToken = jjFillToken();
3742        if (jjnewLexState[jjmatchedKind] != -1)
3743          curLexState = jjnewLexState[jjmatchedKind];
3744            return matchedToken;
3745         }
3746         else
3747         {
3748          if (jjnewLexState[jjmatchedKind] != -1)
3749            curLexState = jjnewLexState[jjmatchedKind];
3750            continue EOFLoop;
3751         }
3752      }
3753      int error_line = input_stream.getEndLine();
3754      int error_column = input_stream.getEndColumn();
3755      String error_after = null;
3756      boolean EOFSeen = false;
3757      try { input_stream.readChar(); input_stream.backup(1); }
3758      catch (java.io.IOException e1) {
3759         EOFSeen = true;
3760         error_after = curPos <= 1 ? "" : input_stream.GetImage();
3761         if (curChar == '\n' || curChar == '\r') {
3762            error_line++;
3763            error_column = 0;
3764         }
3765         else
3766            error_column++;
3767      }
3768      if (!EOFSeen) {
3769         input_stream.backup(1);
3770         error_after = curPos <= 1 ? "" : input_stream.GetImage();
3771      }
3772      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
3773   }
3774 }
3775 
3776 }