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