KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > xquark > xquery > parser > XQueryParserTokenManager


1 /* Generated By:JavaCC: Do not edit this line. XQueryParserTokenManager.java */
2 package org.xquark.xquery.parser;
3 import java.util.*;
4 import org.xquark.xquery.*;
5 import org.xquark.xquery.typing.*;
6 import org.xquark.xquery.parser.util.*;
7 import org.xquark.xquery.parser.primitivefunctions.fnfunctions.*;
8 import org.xquark.xquery.parser.primitivefunctions.xsfunctions.*;
9 import org.xquark.xquery.parser.hinttree.*;
10 import org.xquark.xquery.normalize.*;
11 import org.xquark.util.*;
12 import org.xquark.xpath.*;
13 import org.xquark.xquery.metadata.*;
14 import org.xquark.schema.*;
15 import org.xquark.xquery.metadata.resolver.*;
16 import java.net.*;
17 import org.xml.sax.SAXException JavaDoc;
18
19 public class XQueryParserTokenManager implements XQueryParserConstants
20 {
21         private Stack stateStack = new Stack();
22
23         public Stack getStateStack() {
24                 return stateStack;
25         }
26
27         public void switchState(int newState) {
28                 SwitchTo(newState);
29         }
30
31         public void pushState(int newState) {
32                 stateStack.push(new Integer JavaDoc(newState));
33         }
34
35         public void popState() {
36                 if (!stateStack.isEmpty()) {
37                         SwitchTo(((Integer JavaDoc)stateStack.peek()).intValue());
38                         stateStack.pop();
39                 }
40         }
41
42         void CommonTokenAction(Token t) {
43            System.err.println("Token: "+t+" -- State: "+lexStateNames[curLexState]);
44         }
45
46         void handlePragma() {
47                 Token token = getNextToken();
48                 if (!token.image.equals("hint")) {
49                         pushState(curLexState);
50                         switchState(EXPR_COMMENT);
51                 } else {
52                         pushState(curLexState);
53                         switchState(HINT_STATE);
54                 }
55         }
56
57         void handleCommentAfterQName(Token matchedToken) {
58                 char c = '0';
59                 try {
60                         c = input_stream.readChar();
61         } catch (java.io.IOException JavaDoc ex) {
62                 return;
63         }
64         if (c == ':') {
65             for (int i = 0; i < image.length(); i++) {
66                 switch (image.charAt(i)) {
67                                         case ' ':
68                                         case '\n':
69                                         case '\t':
70                                         case '\r':
71                                         case '(':
72                                                 input_stream.backup(1+image.length()-i);
73                                                 image.setLength(i);
74                                                 matchedToken.kind = QNAME;
75                                                 matchedToken.image = image.toString();
76                                                 switchState(OPERATOR);
77                                                 return;
78                                         default:
79                                                 break;
80                 }
81             }
82         } else {
83             input_stream.backup(1);
84         }
85         }
86   public java.io.PrintStream JavaDoc debugStream = System.out;
87   public void setDebugStream(java.io.PrintStream JavaDoc ds) { debugStream = ds; }
88 private final int jjMoveStringLiteralDfa0_4()
89 {
90    return jjMoveNfa_4(23, 0);
91 }
92 private final void jjCheckNAdd(int state)
93 {
94    if (jjrounds[state] != jjround)
95    {
96       jjstateSet[jjnewStateCnt++] = state;
97       jjrounds[state] = jjround;
98    }
99 }
100 private final void jjAddStates(int start, int end)
101 {
102    do {
103       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
104    } while (start++ != end);
105 }
106 private final void jjCheckNAddTwoStates(int state1, int state2)
107 {
108    jjCheckNAdd(state1);
109    jjCheckNAdd(state2);
110 }
111 private final void jjCheckNAddStates(int start, int end)
112 {
113    do {
114       jjCheckNAdd(jjnextStates[start]);
115    } while (start++ != end);
116 }
117 private final void jjCheckNAddStates(int start)
118 {
119    jjCheckNAdd(jjnextStates[start]);
120    jjCheckNAdd(jjnextStates[start + 1]);
121 }
122 static final long[] jjbitVec0 = {
123    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
124 };
125 static final long[] jjbitVec2 = {
126    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
127 };
128 static final long[] jjbitVec3 = {
129    0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
130 };
131 static final long[] jjbitVec4 = {
132    0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
133 };
134 static final long[] jjbitVec5 = {
135    0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
136 };
137 static final long[] jjbitVec6 = {
138    0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
139 };
140 static final long[] jjbitVec7 = {
141    0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
142 };
143 static final long[] jjbitVec8 = {
144    0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
145 };
146 static final long[] jjbitVec9 = {
147    0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
148 };
149 static final long[] jjbitVec10 = {
150    0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
151 };
152 static final long[] jjbitVec11 = {
153    0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
154 };
155 static final long[] jjbitVec12 = {
156    0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
157 };
158 static final long[] jjbitVec13 = {
159    0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
160 };
161 static final long[] jjbitVec14 = {
162    0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
163 };
164 static final long[] jjbitVec15 = {
165    0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
166 };
167 static final long[] jjbitVec16 = {
168    0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
169 };
170 static final long[] jjbitVec17 = {
171    0x0L, 0x3fffffffeffL, 0x0L, 0x0L
172 };
173 static final long[] jjbitVec18 = {
174    0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
175 };
176 static final long[] jjbitVec19 = {
177    0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
178 };
179 static final long[] jjbitVec20 = {
180    0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
181 };
182 static final long[] jjbitVec21 = {
183    0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
184 };
185 static final long[] jjbitVec22 = {
186    0x4c4000000000L, 0x0L, 0x7L, 0x0L
187 };
188 static final long[] jjbitVec23 = {
189    0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
190 };
191 static final long[] jjbitVec24 = {
192    0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
193 };
194 static final long[] jjbitVec25 = {
195    0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
196 };
197 static final long[] jjbitVec26 = {
198    0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
199 };
200 static final long[] jjbitVec27 = {
201    0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
202 };
203 static final long[] jjbitVec28 = {
204    0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
205 };
206 static final long[] jjbitVec29 = {
207    0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
208 };
209 static final long[] jjbitVec30 = {
210    0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
211 };
212 static final long[] jjbitVec31 = {
213    0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
214 };
215 static final long[] jjbitVec32 = {
216    0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
217 };
218 static final long[] jjbitVec33 = {
219    0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
220 };
221 static final long[] jjbitVec34 = {
222    0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
223 };
224 static final long[] jjbitVec35 = {
225    0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
226 };
227 static final long[] jjbitVec36 = {
228    0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
229 };
230 static final long[] jjbitVec37 = {
231    0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
232 };
233 static final long[] jjbitVec38 = {
234    0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
235 };
236 static final long[] jjbitVec39 = {
237    0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
238 };
239 static final long[] jjbitVec40 = {
240    0x0L, 0x0L, 0x0L, 0x21fff0000L
241 };
242 static final long[] jjbitVec41 = {
243    0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
244 };
245 private final int jjMoveNfa_4(int startState, int curPos)
246 {
247    int[] nextStates;
248    int startsAt = 0;
249    jjnewStateCnt = 26;
250    int i = 1;
251    jjstateSet[0] = startState;
252    int j, kind = 0x7fffffff;
253    for (;;)
254    {
255       if (++jjround == 0x7fffffff)
256          ReInitRounds();
257       if (curChar < 64)
258       {
259          long l = 1L << curChar;
260          MatchLoop: do
261          {
262             switch(jjstateSet[--i])
263             {
264                case 23:
265                   if (curChar == 40)
266                      jjstateSet[jjnewStateCnt++] = 22;
267                   break;
268                case 0:
269                   if (curChar == 58)
270                      jjCheckNAddTwoStates(4, 5);
271                   break;
272                case 1:
273                   if (curChar == 58)
274                      jjCheckNAddTwoStates(2, 21);
275                   break;
276                case 2:
277                   if ((0xfbffffffffffffffL & l) != 0L)
278                      jjCheckNAddTwoStates(2, 21);
279                   break;
280                case 3:
281                   if (curChar == 41)
282                      jjCheckNAddStates(0, 3);
283                   break;
284                case 4:
285                   if (curChar == 40)
286                      jjstateSet[jjnewStateCnt++] = 1;
287                   break;
288                case 5:
289                   if ((0x100002600L & l) != 0L)
290                      jjCheckNAddStates(0, 3);
291                   break;
292                case 21:
293                   if (curChar == 58)
294                      jjstateSet[jjnewStateCnt++] = 3;
295                   break;
296                case 22:
297                   if (curChar == 58)
298                      jjstateSet[jjnewStateCnt++] = 0;
299                   break;
300                case 25:
301                   if ((0x3ff600000000000L & l) == 0L)
302                      break;
303                   if (kind > 251)
304                      kind = 251;
305                   jjstateSet[jjnewStateCnt++] = 25;
306                   break;
307                default : break;
308             }
309          } while(i != startsAt);
310       }
311       else if (curChar < 128)
312       {
313          long l = 1L << (curChar & 077);
314          MatchLoop: do
315          {
316             switch(jjstateSet[--i])
317             {
318                case 23:
319                case 25:
320                   if ((0x7fffffe87fffffeL & l) == 0L)
321                      break;
322                   if (kind > 251)
323                      kind = 251;
324                   jjCheckNAdd(25);
325                   break;
326                case 2:
327                   jjAddStates(4, 5);
328                   break;
329                case 6:
330                   if (curChar == 97 && kind > 1)
331                      kind = 1;
332                   break;
333                case 7:
334                   if (curChar == 109)
335                      jjstateSet[jjnewStateCnt++] = 6;
336                   break;
337                case 8:
338                   if (curChar == 103)
339                      jjstateSet[jjnewStateCnt++] = 7;
340                   break;
341                case 9:
342                   if (curChar == 97)
343                      jjstateSet[jjnewStateCnt++] = 8;
344                   break;
345                case 10:
346                   if (curChar == 114)
347                      jjstateSet[jjnewStateCnt++] = 9;
348                   break;
349                case 11:
350                   if (curChar == 112)
351                      jjstateSet[jjnewStateCnt++] = 10;
352                   break;
353                case 12:
354                   if (curChar == 110 && kind > 1)
355                      kind = 1;
356                   break;
357                case 13:
358                   if (curChar == 111)
359                      jjstateSet[jjnewStateCnt++] = 12;
360                   break;
361                case 14:
362                   if (curChar == 105)
363                      jjstateSet[jjnewStateCnt++] = 13;
364                   break;
365                case 15:
366                   if (curChar == 115)
367                      jjstateSet[jjnewStateCnt++] = 14;
368                   break;
369                case 16:
370                   if (curChar == 110)
371                      jjstateSet[jjnewStateCnt++] = 15;
372                   break;
373                case 17:
374                   if (curChar == 101)
375                      jjstateSet[jjnewStateCnt++] = 16;
376                   break;
377                case 18:
378                   if (curChar == 116)
379                      jjstateSet[jjnewStateCnt++] = 17;
380                   break;
381                case 19:
382                   if (curChar == 120)
383                      jjstateSet[jjnewStateCnt++] = 18;
384                   break;
385                case 20:
386                   if (curChar == 101)
387                      jjstateSet[jjnewStateCnt++] = 19;
388                   break;
389                default : break;
390             }
391          } while(i != startsAt);
392       }
393       else
394       {
395          int hiByte = (int)(curChar >> 8);
396          int i1 = hiByte >> 6;
397          long l1 = 1L << (hiByte & 077);
398          int i2 = (curChar & 0xff) >> 6;
399          long l2 = 1L << (curChar & 077);
400          MatchLoop: do
401          {
402             switch(jjstateSet[--i])
403             {
404                case 23:
405                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
406                      break;
407                   if (kind > 251)
408                      kind = 251;
409                   jjCheckNAdd(25);
410                   break;
411                case 2:
412                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
413                      jjAddStates(4, 5);
414                   break;
415                case 25:
416                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
417                      break;
418                   if (kind > 251)
419                      kind = 251;
420                   jjCheckNAdd(25);
421                   break;
422                default : break;
423             }
424          } while(i != startsAt);
425       }
426       if (kind != 0x7fffffff)
427       {
428          jjmatchedKind = kind;
429          jjmatchedPos = curPos;
430          kind = 0x7fffffff;
431       }
432       ++curPos;
433       if ((i = jjnewStateCnt) == (startsAt = 26 - (jjnewStateCnt = startsAt)))
434          return curPos;
435       try { curChar = input_stream.readChar(); }
436       catch(java.io.IOException JavaDoc e) { return curPos; }
437    }
438 }
439 private final int jjStopStringLiteralDfa_3(int pos, long active0, long active1, long active2, long active3)
440 {
441    switch (pos)
442    {
443       case 0:
444          if ((active3 & 0x1000000000000000L) != 0L)
445          {
446             jjmatchedKind = 253;
447             return -1;
448          }
449          return -1;
450       default :
451          return -1;
452    }
453 }
454 private final int jjStartNfa_3(int pos, long active0, long active1, long active2, long active3)
455 {
456    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0, active1, active2, active3), pos + 1);
457 }
458 private final int jjStopAtPos(int pos, int kind)
459 {
460    jjmatchedKind = kind;
461    jjmatchedPos = pos;
462    return pos + 1;
463 }
464 private final int jjStartNfaWithStates_3(int pos, int kind, int state)
465 {
466    jjmatchedKind = kind;
467    jjmatchedPos = pos;
468    try { curChar = input_stream.readChar(); }
469    catch(java.io.IOException JavaDoc e) { return pos + 1; }
470    return jjMoveNfa_3(state, pos + 1);
471 }
472 private final int jjMoveStringLiteralDfa0_3()
473 {
474    switch(curChar)
475    {
476       case 63:
477          return jjMoveStringLiteralDfa1_3(0x1000000000000000L);
478       default :
479          return jjMoveNfa_3(23, 0);
480    }
481 }
482 private final int jjMoveStringLiteralDfa1_3(long active3)
483 {
484    try { curChar = input_stream.readChar(); }
485    catch(java.io.IOException JavaDoc e) {
486       jjStopStringLiteralDfa_3(0, 0L, 0L, 0L, active3);
487       return 1;
488    }
489    switch(curChar)
490    {
491       case 62:
492          if ((active3 & 0x1000000000000000L) != 0L)
493             return jjStopAtPos(1, 252);
494          break;
495       default :
496          break;
497    }
498    return jjStartNfa_3(0, 0L, 0L, 0L, active3);
499 }
500 static final long[] jjbitVec42 = {
501    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffL
502 };
503 private final int jjMoveNfa_3(int startState, int curPos)
504 {
505    int[] nextStates;
506    int startsAt = 0;
507    jjnewStateCnt = 25;
508    int i = 1;
509    jjstateSet[0] = startState;
510    int j, kind = 0x7fffffff;
511    for (;;)
512    {
513       if (++jjround == 0x7fffffff)
514          ReInitRounds();
515       if (curChar < 64)
516       {
517          long l = 1L << curChar;
518          MatchLoop: do
519          {
520             switch(jjstateSet[--i])
521             {
522                case 23:
523                   if ((0xffffffff00002600L & l) != 0L)
524                   {
525                      if (kind > 253)
526                         kind = 253;
527                   }
528                   if (curChar == 40)
529                      jjstateSet[jjnewStateCnt++] = 22;
530                   break;
531                case 0:
532                   if (curChar == 58)
533                      jjCheckNAddTwoStates(4, 5);
534                   break;
535                case 1:
536                   if (curChar == 58)
537                      jjCheckNAddTwoStates(2, 21);
538                   break;
539                case 2:
540                   if ((0xfbffffffffffffffL & l) != 0L)
541                      jjCheckNAddTwoStates(2, 21);
542                   break;
543                case 3:
544                   if (curChar == 41)
545                      jjCheckNAddStates(0, 3);
546                   break;
547                case 4:
548                   if (curChar == 40)
549                      jjstateSet[jjnewStateCnt++] = 1;
550                   break;
551                case 5:
552                   if ((0x100002600L & l) != 0L)
553                      jjCheckNAddStates(0, 3);
554                   break;
555                case 21:
556                   if (curChar == 58)
557                      jjstateSet[jjnewStateCnt++] = 3;
558                   break;
559                case 22:
560                   if (curChar == 58)
561                      jjstateSet[jjnewStateCnt++] = 0;
562                   break;
563                case 24:
564                   if ((0xffffffff00002600L & l) != 0L && kind > 253)
565                      kind = 253;
566                   break;
567                default : break;
568             }
569          } while(i != startsAt);
570       }
571       else if (curChar < 128)
572       {
573          long l = 1L << (curChar & 077);
574          MatchLoop: do
575          {
576             switch(jjstateSet[--i])
577             {
578                case 23:
579                   if (kind > 253)
580                      kind = 253;
581                   break;
582                case 2:
583                   jjAddStates(4, 5);
584                   break;
585                case 6:
586                   if (curChar == 97 && kind > 1)
587                      kind = 1;
588                   break;
589                case 7:
590                   if (curChar == 109)
591                      jjstateSet[jjnewStateCnt++] = 6;
592                   break;
593                case 8:
594                   if (curChar == 103)
595                      jjstateSet[jjnewStateCnt++] = 7;
596                   break;
597                case 9:
598                   if (curChar == 97)
599                      jjstateSet[jjnewStateCnt++] = 8;
600                   break;
601                case 10:
602                   if (curChar == 114)
603                      jjstateSet[jjnewStateCnt++] = 9;
604                   break;
605                case 11:
606                   if (curChar == 112)
607                      jjstateSet[jjnewStateCnt++] = 10;
608                   break;
609                case 12:
610                   if (curChar == 110 && kind > 1)
611                      kind = 1;
612                   break;
613                case 13:
614                   if (curChar == 111)
615                      jjstateSet[jjnewStateCnt++] = 12;
616                   break;
617                case 14:
618                   if (curChar == 105)
619                      jjstateSet[jjnewStateCnt++] = 13;
620                   break;
621                case 15:
622                   if (curChar == 115)
623                      jjstateSet[jjnewStateCnt++] = 14;
624                   break;
625                case 16:
626                   if (curChar == 110)
627                      jjstateSet[jjnewStateCnt++] = 15;
628                   break;
629                case 17:
630                   if (curChar == 101)
631                      jjstateSet[jjnewStateCnt++] = 16;
632                   break;
633                case 18:
634                   if (curChar == 116)
635                      jjstateSet[jjnewStateCnt++] = 17;
636                   break;
637                case 19:
638                   if (curChar == 120)
639                      jjstateSet[jjnewStateCnt++] = 18;
640                   break;
641                case 20:
642                   if (curChar == 101)
643                      jjstateSet[jjnewStateCnt++] = 19;
644                   break;
645                default : break;
646             }
647          } while(i != startsAt);
648       }
649       else
650       {
651          int hiByte = (int)(curChar >> 8);
652          int i1 = hiByte >> 6;
653          long l1 = 1L << (hiByte & 077);
654          int i2 = (curChar & 0xff) >> 6;
655          long l2 = 1L << (curChar & 077);
656          MatchLoop: do
657          {
658             switch(jjstateSet[--i])
659             {
660                case 23:
661                   if (jjCanMove_3(hiByte, i1, i2, l1, l2) && kind > 253)
662                      kind = 253;
663                   break;
664                case 2:
665                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
666                      jjAddStates(4, 5);
667                   break;
668                default : break;
669             }
670          } while(i != startsAt);
671       }
672       if (kind != 0x7fffffff)
673       {
674          jjmatchedKind = kind;
675          jjmatchedPos = curPos;
676          kind = 0x7fffffff;
677       }
678       ++curPos;
679       if ((i = jjnewStateCnt) == (startsAt = 25 - (jjnewStateCnt = startsAt)))
680          return curPos;
681       try { curChar = input_stream.readChar(); }
682       catch(java.io.IOException JavaDoc e) { return curPos; }
683    }
684 }
685 private final int jjStopStringLiteralDfa_7(int pos, long active0, long active1, long active2, long active3)
686 {
687    switch (pos)
688    {
689       default :
690          return -1;
691    }
692 }
693 private final int jjStartNfa_7(int pos, long active0, long active1, long active2, long active3)
694 {
695    return jjMoveNfa_7(jjStopStringLiteralDfa_7(pos, active0, active1, active2, active3), pos + 1);
696 }
697 private final int jjStartNfaWithStates_7(int pos, int kind, int state)
698 {
699    jjmatchedKind = kind;
700    jjmatchedPos = pos;
701    try { curChar = input_stream.readChar(); }
702    catch(java.io.IOException JavaDoc e) { return pos + 1; }
703    return jjMoveNfa_7(state, pos + 1);
704 }
705 private final int jjMoveStringLiteralDfa0_7()
706 {
707    switch(curChar)
708    {
709       case 62:
710          return jjStopAtPos(0, 242);
711       case 123:
712          return jjStopAtPos(0, 243);
713       default :
714          return jjMoveNfa_7(23, 0);
715    }
716 }
717 private final int jjMoveNfa_7(int startState, int curPos)
718 {
719    int[] nextStates;
720    int startsAt = 0;
721    jjnewStateCnt = 30;
722    int i = 1;
723    jjstateSet[0] = startState;
724    int j, kind = 0x7fffffff;
725    for (;;)
726    {
727       if (++jjround == 0x7fffffff)
728          ReInitRounds();
729       if (curChar < 64)
730       {
731          long l = 1L << curChar;
732          MatchLoop: do
733          {
734             switch(jjstateSet[--i])
735             {
736                case 23:
737                   if ((0x100002600L & l) != 0L)
738                   {
739                      if (kind > 244)
740                         kind = 244;
741                      jjCheckNAdd(24);
742                   }
743                   else if (curChar == 40)
744                      jjstateSet[jjnewStateCnt++] = 22;
745                   break;
746                case 0:
747                   if (curChar == 58)
748                      jjCheckNAddTwoStates(4, 5);
749                   break;
750                case 1:
751                   if (curChar == 58)
752                      jjCheckNAddTwoStates(2, 21);
753                   break;
754                case 2:
755                   if ((0xfbffffffffffffffL & l) != 0L)
756                      jjCheckNAddTwoStates(2, 21);
757                   break;
758                case 3:
759                   if (curChar == 41)
760                      jjCheckNAddStates(0, 3);
761                   break;
762                case 4:
763                   if (curChar == 40)
764                      jjstateSet[jjnewStateCnt++] = 1;
765                   break;
766                case 5:
767                   if ((0x100002600L & l) != 0L)
768                      jjCheckNAddStates(0, 3);
769                   break;
770                case 21:
771                   if (curChar == 58)
772                      jjstateSet[jjnewStateCnt++] = 3;
773                   break;
774                case 22:
775                   if (curChar == 58)
776                      jjstateSet[jjnewStateCnt++] = 0;
777                   break;
778                case 24:
779                   if ((0x100002600L & l) == 0L)
780                      break;
781                   if (kind > 244)
782                      kind = 244;
783                   jjCheckNAdd(24);
784                   break;
785                case 26:
786                   if ((0x3ff600000000000L & l) != 0L)
787                      jjAddStates(6, 7);
788                   break;
789                case 27:
790                   if (curChar == 58)
791                      jjstateSet[jjnewStateCnt++] = 28;
792                   break;
793                case 29:
794                   if ((0x3ff600000000000L & l) == 0L)
795                      break;
796                   if (kind > 245)
797                      kind = 245;
798                   jjstateSet[jjnewStateCnt++] = 29;
799                   break;
800                default : break;
801             }
802          } while(i != startsAt);
803       }
804       else if (curChar < 128)
805       {
806          long l = 1L << (curChar & 077);
807          MatchLoop: do
808          {
809             switch(jjstateSet[--i])
810             {
811                case 23:
812                   if ((0x7fffffe87fffffeL & l) == 0L)
813                      break;
814                   if (kind > 245)
815                      kind = 245;
816                   jjCheckNAddStates(8, 10);
817                   break;
818                case 2:
819                   jjAddStates(4, 5);
820                   break;
821                case 6:
822                   if (curChar == 97 && kind > 1)
823                      kind = 1;
824                   break;
825                case 7:
826                   if (curChar == 109)
827                      jjstateSet[jjnewStateCnt++] = 6;
828                   break;
829                case 8:
830                   if (curChar == 103)
831                      jjstateSet[jjnewStateCnt++] = 7;
832                   break;
833                case 9:
834                   if (curChar == 97)
835                      jjstateSet[jjnewStateCnt++] = 8;
836                   break;
837                case 10:
838                   if (curChar == 114)
839                      jjstateSet[jjnewStateCnt++] = 9;
840                   break;
841                case 11:
842                   if (curChar == 112)
843                      jjstateSet[jjnewStateCnt++] = 10;
844                   break;
845                case 12:
846                   if (curChar == 110 && kind > 1)
847                      kind = 1;
848                   break;
849                case 13:
850                   if (curChar == 111)
851                      jjstateSet[jjnewStateCnt++] = 12;
852                   break;
853                case 14:
854                   if (curChar == 105)
855                      jjstateSet[jjnewStateCnt++] = 13;
856                   break;
857                case 15:
858                   if (curChar == 115)
859                      jjstateSet[jjnewStateCnt++] = 14;
860                   break;
861                case 16:
862                   if (curChar == 110)
863                      jjstateSet[jjnewStateCnt++] = 15;
864                   break;
865                case 17:
866                   if (curChar == 101)
867                      jjstateSet[jjnewStateCnt++] = 16;
868                   break;
869                case 18:
870                   if (curChar == 116)
871                      jjstateSet[jjnewStateCnt++] = 17;
872                   break;
873                case 19:
874                   if (curChar == 120)
875                      jjstateSet[jjnewStateCnt++] = 18;
876                   break;
877                case 20:
878                   if (curChar == 101)
879                      jjstateSet[jjnewStateCnt++] = 19;
880                   break;
881                case 26:
882                   if ((0x7fffffe87fffffeL & l) != 0L)
883                      jjCheckNAddTwoStates(26, 27);
884                   break;
885                case 28:
886                case 29:
887                   if ((0x7fffffe87fffffeL & l) == 0L)
888                      break;
889                   if (kind > 245)
890                      kind = 245;
891                   jjCheckNAdd(29);
892                   break;
893                default : break;
894             }
895          } while(i != startsAt);
896       }
897       else
898       {
899          int hiByte = (int)(curChar >> 8);
900          int i1 = hiByte >> 6;
901          long l1 = 1L << (hiByte & 077);
902          int i2 = (curChar & 0xff) >> 6;
903          long l2 = 1L << (curChar & 077);
904          MatchLoop: do
905          {
906             switch(jjstateSet[--i])
907             {
908                case 23:
909                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
910                      break;
911                   if (kind > 245)
912                      kind = 245;
913                   jjCheckNAddStates(8, 10);
914                   break;
915                case 2:
916                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
917                      jjAddStates(4, 5);
918                   break;
919                case 26:
920                   if (jjCanMove_2(hiByte, i1, i2, l1, l2))
921                      jjCheckNAddTwoStates(26, 27);
922                   break;
923                case 28:
924                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
925                      break;
926                   if (kind > 245)
927                      kind = 245;
928                   jjCheckNAdd(29);
929                   break;
930                case 29:
931                   if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
932                      break;
933                   if (kind > 245)
934                      kind = 245;
935                   jjCheckNAdd(29);
936                   break;
937                default : break;
938             }
939          } while(i != startsAt);
940       }
941       if (kind != 0x7fffffff)
942       {
943          jjmatchedKind = kind;
944          jjmatchedPos = curPos;
945          kind = 0x7fffffff;
946       }
947       ++curPos;
948       if ((i = jjnewStateCnt) == (startsAt = 30 - (jjnewStateCnt = startsAt)))
949          return curPos;
950       try { curChar = input_stream.readChar(); }
951       catch(java.io.IOException JavaDoc e) { return curPos; }
952    }
953 }
954 private final int jjStopStringLiteralDfa_6(int pos, long active0, long active1, long active2, long active3)
955 {
956    switch (pos)
957    {
958       case 0:
959          if ((active3 & 0x40000000000000L) != 0L)
960          {
961             jjmatchedKind = 247;
962             return -1;
963          }
964          return -1;
965       case 1:
966          if ((active3 & 0x40000000000000L) != 0L)
967          {
968             if (jjmatchedPos == 0)
969             {
970                jjmatchedKind = 247;
971                jjmatchedPos = 0;
972             }
973             return -1;
974          }
975          return -1;
976       default :
977          return -1;
978    }
979 }
980 private final int jjStartNfa_6(int pos, long active0, long active1, long active2, long active3)
981 {
982    return jjMoveNfa_6(jjStopStringLiteralDfa_6(pos, active0, active1, active2, active3), pos + 1);
983 }
984 private final int jjStartNfaWithStates_6(int pos, int kind, int state)
985 {
986    jjmatchedKind = kind;
987    jjmatchedPos = pos;
988    try { curChar = input_stream.readChar(); }
989    catch(java.io.IOException JavaDoc e) { return pos + 1; }
990    return jjMoveNfa_6(state, pos + 1);
991 }
992 private final int jjMoveStringLiteralDfa0_6()
993 {
994    switch(curChar)
995    {
996       case 45:
997          return jjMoveStringLiteralDfa1_6(0x40000000000000L);
998       default :
999          return jjMoveNfa_6(23, 0);
1000   }
1001}
1002private final int jjMoveStringLiteralDfa1_6(long active3)
1003{
1004   try { curChar = input_stream.readChar(); }
1005   catch(java.io.IOException JavaDoc e) {
1006      jjStopStringLiteralDfa_6(0, 0L, 0L, 0L, active3);
1007      return 1;
1008   }
1009   switch(curChar)
1010   {
1011      case 45:
1012         return jjMoveStringLiteralDfa2_6(active3, 0x40000000000000L);
1013      default :
1014         break;
1015   }
1016   return jjStartNfa_6(0, 0L, 0L, 0L, active3);
1017}
1018private final int jjMoveStringLiteralDfa2_6(long old3, long active3)
1019{
1020   if (((active3 &= old3)) == 0L)
1021      return jjStartNfa_6(0, 0L, 0L, 0L, old3);
1022   try { curChar = input_stream.readChar(); }
1023   catch(java.io.IOException JavaDoc e) {
1024      jjStopStringLiteralDfa_6(1, 0L, 0L, 0L, active3);
1025      return 2;
1026   }
1027   switch(curChar)
1028   {
1029      case 62:
1030         if ((active3 & 0x40000000000000L) != 0L)
1031            return jjStopAtPos(2, 246);
1032         break;
1033      default :
1034         break;
1035   }
1036   return jjStartNfa_6(1, 0L, 0L, 0L, active3);
1037}
1038private final int jjMoveNfa_6(int startState, int curPos)
1039{
1040   int[] nextStates;
1041   int startsAt = 0;
1042   jjnewStateCnt = 25;
1043   int i = 1;
1044   jjstateSet[0] = startState;
1045   int j, kind = 0x7fffffff;
1046   for (;;)
1047   {
1048      if (++jjround == 0x7fffffff)
1049         ReInitRounds();
1050      if (curChar < 64)
1051      {
1052         long l = 1L << curChar;
1053         MatchLoop: do
1054         {
1055            switch(jjstateSet[--i])
1056            {
1057               case 23:
1058                  if ((0xffffffff00002600L & l) != 0L)
1059                  {
1060                     if (kind > 247)
1061                        kind = 247;
1062                  }
1063                  if (curChar == 40)
1064                     jjstateSet[jjnewStateCnt++] = 22;
1065                  break;
1066               case 0:
1067                  if (curChar == 58)
1068                     jjCheckNAddTwoStates(4, 5);
1069                  break;
1070               case 1:
1071                  if (curChar == 58)
1072                     jjCheckNAddTwoStates(2, 21);
1073                  break;
1074               case 2:
1075                  if ((0xfbffffffffffffffL & l) != 0L)
1076                     jjCheckNAddTwoStates(2, 21);
1077                  break;
1078               case 3:
1079                  if (curChar == 41)
1080                     jjCheckNAddStates(0, 3);
1081                  break;
1082               case 4:
1083                  if (curChar == 40)
1084                     jjstateSet[jjnewStateCnt++] = 1;
1085                  break;
1086               case 5:
1087                  if ((0x100002600L & l) != 0L)
1088                     jjCheckNAddStates(0, 3);
1089                  break;
1090               case 21:
1091                  if (curChar == 58)
1092                     jjstateSet[jjnewStateCnt++] = 3;
1093                  break;
1094               case 22:
1095                  if (curChar == 58)
1096                     jjstateSet[jjnewStateCnt++] = 0;
1097                  break;
1098               case 24:
1099                  if ((0xffffffff00002600L & l) != 0L && kind > 247)
1100                     kind = 247;
1101                  break;
1102               default : break;
1103            }
1104         } while(i != startsAt);
1105      }
1106      else if (curChar < 128)
1107      {
1108         long l = 1L << (curChar & 077);
1109         MatchLoop: do
1110         {
1111            switch(jjstateSet[--i])
1112            {
1113               case 23:
1114                  if (kind > 247)
1115                     kind = 247;
1116                  break;
1117               case 2:
1118                  jjAddStates(4, 5);
1119                  break;
1120               case 6:
1121                  if (curChar == 97 && kind > 1)
1122                     kind = 1;
1123                  break;
1124               case 7:
1125                  if (curChar == 109)
1126                     jjstateSet[jjnewStateCnt++] = 6;
1127                  break;
1128               case 8:
1129                  if (curChar == 103)
1130                     jjstateSet[jjnewStateCnt++] = 7;
1131                  break;
1132               case 9:
1133                  if (curChar == 97)
1134                     jjstateSet[jjnewStateCnt++] = 8;
1135                  break;
1136               case 10:
1137                  if (curChar == 114)
1138                     jjstateSet[jjnewStateCnt++] = 9;
1139                  break;
1140               case 11:
1141                  if (curChar == 112)
1142                     jjstateSet[jjnewStateCnt++] = 10;
1143                  break;
1144               case 12:
1145                  if (curChar == 110 && kind > 1)
1146                     kind = 1;
1147                  break;
1148               case 13:
1149                  if (curChar == 111)
1150                     jjstateSet[jjnewStateCnt++] = 12;
1151                  break;
1152               case 14:
1153                  if (curChar == 105)
1154                     jjstateSet[jjnewStateCnt++] = 13;
1155                  break;
1156               case 15:
1157                  if (curChar == 115)
1158                     jjstateSet[jjnewStateCnt++] = 14;
1159                  break;
1160               case 16:
1161                  if (curChar == 110)
1162                     jjstateSet[jjnewStateCnt++] = 15;
1163                  break;
1164               case 17:
1165                  if (curChar == 101)
1166                     jjstateSet[jjnewStateCnt++] = 16;
1167                  break;
1168               case 18:
1169                  if (curChar == 116)
1170                     jjstateSet[jjnewStateCnt++] = 17;
1171                  break;
1172               case 19:
1173                  if (curChar == 120)
1174                     jjstateSet[jjnewStateCnt++] = 18;
1175                  break;
1176               case 20:
1177                  if (curChar == 101)
1178                     jjstateSet[jjnewStateCnt++] = 19;
1179                  break;
1180               default : break;
1181            }
1182         } while(i != startsAt);
1183      }
1184      else
1185      {
1186         int hiByte = (int)(curChar >> 8);
1187         int i1 = hiByte >> 6;
1188         long l1 = 1L << (hiByte & 077);
1189         int i2 = (curChar & 0xff) >> 6;
1190         long l2 = 1L << (curChar & 077);
1191         MatchLoop: do
1192         {
1193            switch(jjstateSet[--i])
1194            {
1195               case 23:
1196                  if (jjCanMove_3(hiByte, i1, i2, l1, l2) && kind > 247)
1197                     kind = 247;
1198                  break;
1199               case 2:
1200                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1201                     jjAddStates(4, 5);
1202                  break;
1203               default : break;
1204            }
1205         } while(i != startsAt);
1206      }
1207      if (kind != 0x7fffffff)
1208      {
1209         jjmatchedKind = kind;
1210         jjmatchedPos = curPos;
1211         kind = 0x7fffffff;
1212      }
1213      ++curPos;
1214      if ((i = jjnewStateCnt) == (startsAt = 25 - (jjnewStateCnt = startsAt)))
1215         return curPos;
1216      try { curChar = input_stream.readChar(); }
1217      catch(java.io.IOException JavaDoc e) { return curPos; }
1218   }
1219}
1220private final int jjStopStringLiteralDfa_13(int pos, long active0, long active1, long active2, long active3)
1221{
1222   switch (pos)
1223   {
1224      case 0:
1225         if ((active3 & 0x18000L) != 0L)
1226         {
1227            jjmatchedKind = 211;
1228            return 60;
1229         }
1230         return -1;
1231      case 1:
1232         if ((active3 & 0x18000L) != 0L)
1233         {
1234            jjmatchedKind = 211;
1235            jjmatchedPos = 1;
1236            return 60;
1237         }
1238         return -1;
1239      case 2:
1240         if ((active3 & 0x18000L) != 0L)
1241         {
1242            jjmatchedKind = 211;
1243            jjmatchedPos = 2;
1244            return 60;
1245         }
1246         return -1;
1247      case 3:
1248         if ((active3 & 0x18000L) != 0L)
1249         {
1250            jjmatchedKind = 211;
1251            jjmatchedPos = 3;
1252            return 60;
1253         }
1254         return -1;
1255      case 4:
1256         if ((active3 & 0x18000L) != 0L)
1257         {
1258            jjmatchedKind = 211;
1259            jjmatchedPos = 4;
1260            return 60;
1261         }
1262         return -1;
1263      case 5:
1264         if ((active3 & 0x10000L) != 0L)
1265            return 60;
1266         if ((active3 & 0x8000L) != 0L)
1267         {
1268            jjmatchedKind = 211;
1269            jjmatchedPos = 5;
1270            return 60;
1271         }
1272         return -1;
1273      default :
1274         return -1;
1275   }
1276}
1277private final int jjStartNfa_13(int pos, long active0, long active1, long active2, long active3)
1278{
1279   return jjMoveNfa_13(jjStopStringLiteralDfa_13(pos, active0, active1, active2, active3), pos + 1);
1280}
1281private final int jjStartNfaWithStates_13(int pos, int kind, int state)
1282{
1283   jjmatchedKind = kind;
1284   jjmatchedPos = pos;
1285   try { curChar = input_stream.readChar(); }
1286   catch(java.io.IOException JavaDoc e) { return pos + 1; }
1287   return jjMoveNfa_13(state, pos + 1);
1288}
1289private final int jjMoveStringLiteralDfa0_13()
1290{
1291   switch(curChar)
1292   {
1293      case 41:
1294         return jjStopAtPos(0, 203);
1295      case 42:
1296         return jjStopAtPos(0, 210);
1297      case 47:
1298         return jjStopAtPos(0, 205);
1299      case 64:
1300         return jjStopAtPos(0, 206);
1301      case 99:
1302         return jjMoveStringLiteralDfa1_13(0x8000L);
1303      case 103:
1304         return jjMoveStringLiteralDfa1_13(0x10000L);
1305      case 123:
1306         return jjStopAtPos(0, 202);
1307      default :
1308         return jjMoveNfa_13(23, 0);
1309   }
1310}
1311private final int jjMoveStringLiteralDfa1_13(long active3)
1312{
1313   try { curChar = input_stream.readChar(); }
1314   catch(java.io.IOException JavaDoc e) {
1315      jjStopStringLiteralDfa_13(0, 0L, 0L, 0L, active3);
1316      return 1;
1317   }
1318   switch(curChar)
1319   {
1320      case 108:
1321         return jjMoveStringLiteralDfa2_13(active3, 0x10000L);
1322      case 111:
1323         return jjMoveStringLiteralDfa2_13(active3, 0x8000L);
1324      default :
1325         break;
1326   }
1327   return jjStartNfa_13(0, 0L, 0L, 0L, active3);
1328}
1329private final int jjMoveStringLiteralDfa2_13(long old3, long active3)
1330{
1331   if (((active3 &= old3)) == 0L)
1332      return jjStartNfa_13(0, 0L, 0L, 0L, old3);
1333   try { curChar = input_stream.readChar(); }
1334   catch(java.io.IOException JavaDoc e) {
1335      jjStopStringLiteralDfa_13(1, 0L, 0L, 0L, active3);
1336      return 2;
1337   }
1338   switch(curChar)
1339   {
1340      case 110:
1341         return jjMoveStringLiteralDfa3_13(active3, 0x8000L);
1342      case 111:
1343         return jjMoveStringLiteralDfa3_13(active3, 0x10000L);
1344      default :
1345         break;
1346   }
1347   return jjStartNfa_13(1, 0L, 0L, 0L, active3);
1348}
1349private final int jjMoveStringLiteralDfa3_13(long old3, long active3)
1350{
1351   if (((active3 &= old3)) == 0L)
1352      return jjStartNfa_13(1, 0L, 0L, 0L, old3);
1353   try { curChar = input_stream.readChar(); }
1354   catch(java.io.IOException JavaDoc e) {
1355      jjStopStringLiteralDfa_13(2, 0L, 0L, 0L, active3);
1356      return 3;
1357   }
1358   switch(curChar)
1359   {
1360      case 98:
1361         return jjMoveStringLiteralDfa4_13(active3, 0x10000L);
1362      case 116:
1363         return jjMoveStringLiteralDfa4_13(active3, 0x8000L);
1364      default :
1365         break;
1366   }
1367   return jjStartNfa_13(2, 0L, 0L, 0L, active3);
1368}
1369private final int jjMoveStringLiteralDfa4_13(long old3, long active3)
1370{
1371   if (((active3 &= old3)) == 0L)
1372      return jjStartNfa_13(2, 0L, 0L, 0L, old3);
1373   try { curChar = input_stream.readChar(); }
1374   catch(java.io.IOException JavaDoc e) {
1375      jjStopStringLiteralDfa_13(3, 0L, 0L, 0L, active3);
1376      return 4;
1377   }
1378   switch(curChar)
1379   {
1380      case 97:
1381         return jjMoveStringLiteralDfa5_13(active3, 0x10000L);
1382      case 101:
1383         return jjMoveStringLiteralDfa5_13(active3, 0x8000L);
1384      default :
1385         break;
1386   }
1387   return jjStartNfa_13(3, 0L, 0L, 0L, active3);
1388}
1389private final int jjMoveStringLiteralDfa5_13(long old3, long active3)
1390{
1391   if (((active3 &= old3)) == 0L)
1392      return jjStartNfa_13(3, 0L, 0L, 0L, old3);
1393   try { curChar = input_stream.readChar(); }
1394   catch(java.io.IOException JavaDoc e) {
1395      jjStopStringLiteralDfa_13(4, 0L, 0L, 0L, active3);
1396      return 5;
1397   }
1398   switch(curChar)
1399   {
1400      case 108:
1401         if ((active3 & 0x10000L) != 0L)
1402            return jjStartNfaWithStates_13(5, 208, 60);
1403         break;
1404      case 120:
1405         return jjMoveStringLiteralDfa6_13(active3, 0x8000L);
1406      default :
1407         break;
1408   }
1409   return jjStartNfa_13(4, 0L, 0L, 0L, active3);
1410}
1411private final int jjMoveStringLiteralDfa6_13(long old3, long active3)
1412{
1413   if (((active3 &= old3)) == 0L)
1414      return jjStartNfa_13(4, 0L, 0L, 0L, old3);
1415   try { curChar = input_stream.readChar(); }
1416   catch(java.io.IOException JavaDoc e) {
1417      jjStopStringLiteralDfa_13(5, 0L, 0L, 0L, active3);
1418      return 6;
1419   }
1420   switch(curChar)
1421   {
1422      case 116:
1423         if ((active3 & 0x8000L) != 0L)
1424            return jjStartNfaWithStates_13(6, 207, 60);
1425         break;
1426      default :
1427         break;
1428   }
1429   return jjStartNfa_13(5, 0L, 0L, 0L, active3);
1430}
1431private final int jjMoveNfa_13(int startState, int curPos)
1432{
1433   int[] nextStates;
1434   int startsAt = 0;
1435   jjnewStateCnt = 60;
1436   int i = 1;
1437   jjstateSet[0] = startState;
1438   int j, kind = 0x7fffffff;
1439   for (;;)
1440   {
1441      if (++jjround == 0x7fffffff)
1442         ReInitRounds();
1443      if (curChar < 64)
1444      {
1445         long l = 1L << curChar;
1446         MatchLoop: do
1447         {
1448            switch(jjstateSet[--i])
1449            {
1450               case 60:
1451                  if ((0x3ff600000000000L & l) != 0L)
1452                  {
1453                     if (kind > 211)
1454                        kind = 211;
1455                     jjCheckNAdd(59);
1456                  }
1457                  else if (curChar == 58)
1458                     jjstateSet[jjnewStateCnt++] = 58;
1459                  if ((0x3ff600000000000L & l) != 0L)
1460                     jjCheckNAddTwoStates(56, 57);
1461                  break;
1462               case 23:
1463                  if (curChar == 39)
1464                     jjCheckNAddTwoStates(42, 43);
1465                  else if (curChar == 34)
1466                     jjCheckNAddTwoStates(39, 40);
1467                  else if (curChar == 40)
1468                     jjstateSet[jjnewStateCnt++] = 22;
1469                  break;
1470               case 0:
1471                  if (curChar == 58)
1472                     jjCheckNAddTwoStates(4, 5);
1473                  break;
1474               case 1:
1475                  if (curChar == 58)
1476                     jjCheckNAddTwoStates(2, 21);
1477                  break;
1478               case 2:
1479                  if ((0xfbffffffffffffffL & l) != 0L)
1480                     jjCheckNAddTwoStates(2, 21);
1481                  break;
1482               case 3:
1483                  if (curChar == 41)
1484                     jjCheckNAddStates(0, 3);
1485                  break;
1486               case 4:
1487                  if (curChar == 40)
1488                     jjstateSet[jjnewStateCnt++] = 1;
1489                  break;
1490               case 5:
1491                  if ((0x100002600L & l) != 0L)
1492                     jjCheckNAddStates(0, 3);
1493                  break;
1494               case 21:
1495                  if (curChar == 58)
1496                     jjstateSet[jjnewStateCnt++] = 3;
1497                  break;
1498               case 22:
1499                  if (curChar == 58)
1500                     jjstateSet[jjnewStateCnt++] = 0;
1501                  break;
1502               case 25:
1503                  if (curChar == 58)
1504                     jjCheckNAddTwoStates(26, 31);
1505                  break;
1506               case 26:
1507                  if ((0xfbffffffffffffffL & l) != 0L)
1508                     jjCheckNAddTwoStates(26, 31);
1509                  break;
1510               case 27:
1511                  if (curChar == 41)
1512                     jjCheckNAddStates(11, 13);
1513                  break;
1514               case 28:
1515                  if (curChar == 40)
1516                     jjstateSet[jjnewStateCnt++] = 25;
1517                  break;
1518               case 29:
1519                  if ((0x100002600L & l) != 0L)
1520                     jjCheckNAddStates(11, 13);
1521                  break;
1522               case 30:
1523                  if (curChar == 40 && kind > 204)
1524                     kind = 204;
1525                  break;
1526               case 31:
1527                  if (curChar == 58)
1528                     jjstateSet[jjnewStateCnt++] = 27;
1529                  break;
1530               case 38:
1531                  if (curChar == 34)
1532                     jjCheckNAddTwoStates(39, 40);
1533                  break;
1534               case 39:
1535                  if ((0xfffffffbffffffffL & l) != 0L)
1536                     jjCheckNAddTwoStates(39, 40);
1537                  break;
1538               case 40:
1539                  if (curChar == 34 && kind > 209)
1540                     kind = 209;
1541                  break;
1542               case 41:
1543                  if (curChar == 39)
1544                     jjCheckNAddTwoStates(42, 43);
1545                  break;
1546               case 42:
1547                  if ((0xffffff7fffffffffL & l) != 0L)
1548                     jjCheckNAddTwoStates(42, 43);
1549                  break;
1550               case 43:
1551                  if (curChar == 39 && kind > 209)
1552                     kind = 209;
1553                  break;
1554               case 45:
1555                  if (curChar == 58)
1556                     jjCheckNAddTwoStates(46, 51);
1557                  break;
1558               case 46:
1559                  if ((0xfbffffffffffffffL & l) != 0L)
1560                     jjCheckNAddTwoStates(46, 51);
1561                  break;
1562               case 47:
1563                  if (curChar == 41)
1564                     jjCheckNAddStates(14, 16);
1565                  break;
1566               case 48:
1567                  if (curChar == 40)
1568                     jjstateSet[jjnewStateCnt++] = 45;
1569                  break;
1570               case 49:
1571                  if ((0x100002600L & l) != 0L)
1572                     jjCheckNAddStates(14, 16);
1573                  break;
1574               case 50:
1575                  if (curChar == 40 && kind > 212)
1576                     kind = 212;
1577                  break;
1578               case 51:
1579                  if (curChar == 58)
1580                     jjstateSet[jjnewStateCnt++] = 47;
1581                  break;
1582               case 56:
1583                  if ((0x3ff600000000000L & l) != 0L)
1584                     jjCheckNAddTwoStates(56, 57);
1585                  break;
1586               case 57:
1587                  if (curChar == 58)
1588                     jjstateSet[jjnewStateCnt++] = 58;
1589                  break;
1590               case 59:
1591                  if ((0x3ff600000000000L & l) == 0L)
1592                     break;
1593                  if (kind > 211)
1594                     kind = 211;
1595                  jjCheckNAdd(59);
1596                  break;
1597               default : break;
1598            }
1599         } while(i != startsAt);
1600      }
1601      else if (curChar < 128)
1602      {
1603         long l = 1L << (curChar & 077);
1604         MatchLoop: do
1605         {
1606            switch(jjstateSet[--i])
1607            {
1608               case 60:
1609                  if ((0x7fffffe87fffffeL & l) != 0L)
1610                  {
1611                     if (kind > 211)
1612                        kind = 211;
1613                     jjCheckNAdd(59);
1614                  }
1615                  if ((0x7fffffe87fffffeL & l) != 0L)
1616                     jjCheckNAddTwoStates(56, 57);
1617                  break;
1618               case 23:
1619                  if ((0x7fffffe87fffffeL & l) != 0L)
1620                  {
1621                     if (kind > 211)
1622                        kind = 211;
1623                     jjCheckNAddStates(17, 19);
1624                  }
1625                  if (curChar == 116)
1626                     jjstateSet[jjnewStateCnt++] = 53;
1627                  else if (curChar == 101)
1628                     jjstateSet[jjnewStateCnt++] = 36;
1629                  break;
1630               case 2:
1631                  jjAddStates(4, 5);
1632                  break;
1633               case 6:
1634                  if (curChar == 97 && kind > 1)
1635                     kind = 1;
1636                  break;
1637               case 7:
1638                  if (curChar == 109)
1639                     jjstateSet[jjnewStateCnt++] = 6;
1640                  break;
1641               case 8:
1642                  if (curChar == 103)
1643                     jjstateSet[jjnewStateCnt++] = 7;
1644                  break;
1645               case 9:
1646                  if (curChar == 97)
1647                     jjstateSet[jjnewStateCnt++] = 8;
1648                  break;
1649               case 10:
1650                  if (curChar == 114)
1651                     jjstateSet[jjnewStateCnt++] = 9;
1652                  break;
1653               case 11:
1654                  if (curChar == 112)
1655                     jjstateSet[jjnewStateCnt++] = 10;
1656                  break;
1657               case 12:
1658                  if (curChar == 110 && kind > 1)
1659                     kind = 1;
1660                  break;
1661               case 13:
1662                  if (curChar == 111)
1663                     jjstateSet[jjnewStateCnt++] = 12;
1664                  break;
1665               case 14:
1666                  if (curChar == 105)
1667                     jjstateSet[jjnewStateCnt++] = 13;
1668                  break;
1669               case 15:
1670                  if (curChar == 115)
1671                     jjstateSet[jjnewStateCnt++] = 14;
1672                  break;
1673               case 16:
1674                  if (curChar == 110)
1675                     jjstateSet[jjnewStateCnt++] = 15;
1676                  break;
1677               case 17:
1678                  if (curChar == 101)
1679                     jjstateSet[jjnewStateCnt++] = 16;
1680                  break;
1681               case 18:
1682                  if (curChar == 116)
1683                     jjstateSet[jjnewStateCnt++] = 17;
1684                  break;
1685               case 19:
1686                  if (curChar == 120)
1687                     jjstateSet[jjnewStateCnt++] = 18;
1688                  break;
1689               case 20:
1690                  if (curChar == 101)
1691                     jjstateSet[jjnewStateCnt++] = 19;
1692                  break;
1693               case 24:
1694                  if (curChar == 116)
1695                     jjAddStates(11, 13);
1696                  break;
1697               case 26:
1698                  jjAddStates(20, 21);
1699                  break;
1700               case 32:
1701                  if (curChar == 110)
1702                     jjstateSet[jjnewStateCnt++] = 24;
1703                  break;
1704               case 33:
1705                  if (curChar == 101)
1706                     jjstateSet[jjnewStateCnt++] = 32;
1707                  break;
1708               case 34:
1709                  if (curChar == 109)
1710                     jjstateSet[jjnewStateCnt++] = 33;
1711                  break;
1712               case 35:
1713                  if (curChar == 101)
1714                     jjstateSet[jjnewStateCnt++] = 34;
1715                  break;
1716               case 36:
1717                  if (curChar == 108)
1718                     jjstateSet[jjnewStateCnt++] = 35;
1719                  break;
1720               case 37:
1721                  if (curChar == 101)
1722                     jjstateSet[jjnewStateCnt++] = 36;
1723                  break;
1724               case 39:
1725                  jjAddStates(22, 23);
1726                  break;
1727               case 42:
1728                  jjAddStates(24, 25);
1729                  break;
1730               case 44:
1731                  if (curChar == 101)
1732                     jjAddStates(14, 16);
1733                  break;
1734               case 46:
1735                  jjAddStates(26, 27);
1736                  break;
1737               case 52:
1738                  if (curChar == 112)
1739                     jjstateSet[jjnewStateCnt++] = 44;
1740                  break;
1741               case 53:
1742                  if (curChar == 121)
1743                     jjstateSet[jjnewStateCnt++] = 52;
1744                  break;
1745               case 54:
1746                  if (curChar == 116)
1747                     jjstateSet[jjnewStateCnt++] = 53;
1748                  break;
1749               case 55:
1750                  if ((0x7fffffe87fffffeL & l) == 0L)
1751                     break;
1752                  if (kind > 211)
1753                     kind = 211;
1754                  jjCheckNAddStates(17, 19);
1755                  break;
1756               case 56:
1757                  if ((0x7fffffe87fffffeL & l) != 0L)
1758                     jjCheckNAddTwoStates(56, 57);
1759                  break;
1760               case 58:
1761                  if ((0x7fffffe87fffffeL & l) == 0L)
1762                     break;
1763                  if (kind > 211)
1764                     kind = 211;
1765                  jjCheckNAdd(59);
1766                  break;
1767               case 59:
1768                  if ((0x7fffffe87fffffeL & l) == 0L)
1769                     break;
1770                  if (kind > 211)
1771                     kind = 211;
1772                  jjCheckNAdd(59);
1773                  break;
1774               default : break;
1775            }
1776         } while(i != startsAt);
1777      }
1778      else
1779      {
1780         int hiByte = (int)(curChar >> 8);
1781         int i1 = hiByte >> 6;
1782         long l1 = 1L << (hiByte & 077);
1783         int i2 = (curChar & 0xff) >> 6;
1784         long l2 = 1L << (curChar & 077);
1785         MatchLoop: do
1786         {
1787            switch(jjstateSet[--i])
1788            {
1789               case 60:
1790                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1791                     jjCheckNAddTwoStates(56, 57);
1792                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1793                  {
1794                     if (kind > 211)
1795                        kind = 211;
1796                     jjCheckNAdd(59);
1797                  }
1798                  break;
1799               case 23:
1800                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1801                     break;
1802                  if (kind > 211)
1803                     kind = 211;
1804                  jjCheckNAddStates(17, 19);
1805                  break;
1806               case 2:
1807                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1808                     jjAddStates(4, 5);
1809                  break;
1810               case 26:
1811                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1812                     jjAddStates(20, 21);
1813                  break;
1814               case 39:
1815                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1816                     jjAddStates(22, 23);
1817                  break;
1818               case 42:
1819                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1820                     jjAddStates(24, 25);
1821                  break;
1822               case 46:
1823                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1824                     jjAddStates(26, 27);
1825                  break;
1826               case 56:
1827                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1828                     jjCheckNAddTwoStates(56, 57);
1829                  break;
1830               case 58:
1831                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1832                     break;
1833                  if (kind > 211)
1834                     kind = 211;
1835                  jjCheckNAdd(59);
1836                  break;
1837               case 59:
1838                  if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1839                     break;
1840                  if (kind > 211)
1841                     kind = 211;
1842                  jjCheckNAdd(59);
1843                  break;
1844               default : break;
1845            }
1846         } while(i != startsAt);
1847      }
1848      if (kind != 0x7fffffff)
1849      {
1850         jjmatchedKind = kind;
1851         jjmatchedPos = curPos;
1852         kind = 0x7fffffff;
1853      }
1854      ++curPos;
1855      if ((i = jjnewStateCnt) == (startsAt = 60 - (jjnewStateCnt = startsAt)))
1856         return curPos;
1857      try { curChar = input_stream.readChar(); }
1858      catch(java.io.IOException JavaDoc e) { return curPos; }
1859   }
1860}
1861private final int jjStopStringLiteralDfa_5(int pos, long active0, long active1, long active2, long active3)
1862{
1863   switch (pos)
1864   {
1865      case 0:
1866         if ((active3 & 0x300000000000000L) != 0L)
1867         {
1868            jjmatchedKind = 250;
1869            return -1;
1870         }
1871         return -1;
1872      case 1:
1873         if ((active3 & 0x300000000000000L) != 0L)
1874         {
1875            if (jjmatchedPos == 0)
1876            {
1877               jjmatchedKind = 250;
1878               jjmatchedPos = 0;
1879            }
1880            return -1;
1881         }
1882         return -1;
1883      default :
1884         return -1;
1885   }
1886}
1887private final int jjStartNfa_5(int pos, long active0, long active1, long active2, long active3)
1888{
1889   return jjMoveNfa_5(jjStopStringLiteralDfa_5(pos, active0, active1, active2, active3), pos + 1);
1890}
1891private final int jjStartNfaWithStates_5(int pos, int kind, int state)
1892{
1893   jjmatchedKind = kind;
1894   jjmatchedPos = pos;
1895   try { curChar = input_stream.readChar(); }
1896   catch(java.io.IOException JavaDoc e) { return pos + 1; }
1897   return jjMoveNfa_5(state, pos + 1);
1898}
1899private final int jjMoveStringLiteralDfa0_5()
1900{
1901   switch(curChar)
1902   {
1903      case 45:
1904         return jjMoveStringLiteralDfa1_5(0x200000000000000L);
1905      case 58:
1906         return jjMoveStringLiteralDfa1_5(0x100000000000000L);
1907      default :
1908         return jjMoveNfa_5(23, 0);
1909   }
1910}
1911private final int jjMoveStringLiteralDfa1_5(long active3)
1912{
1913   try { curChar = input_stream.readChar(); }
1914   catch(java.io.IOException JavaDoc e) {
1915      jjStopStringLiteralDfa_5(0, 0L, 0L, 0L, active3);
1916      return 1;
1917   }
1918   switch(curChar)
1919   {
1920      case 41:
1921         if ((active3 & 0x100000000000000L) != 0L)
1922            return jjStopAtPos(1, 248);
1923         break;
1924      case 45:
1925         return jjMoveStringLiteralDfa2_5(active3, 0x200000000000000L);
1926      default :
1927         break;
1928   }
1929   return jjStartNfa_5(0, 0L, 0L, 0L, active3);
1930}
1931private final int jjMoveStringLiteralDfa2_5(long old3, long active3)
1932{
1933   if (((active3 &= old3)) == 0L)
1934      return jjStartNfa_5(0, 0L, 0L, 0L, old3);
1935   try { curChar = input_stream.readChar(); }
1936   catch(java.io.IOException JavaDoc e) {
1937      jjStopStringLiteralDfa_5(1, 0L, 0L, 0L, active3);
1938      return 2;
1939   }
1940   switch(curChar)
1941   {
1942      case 125:
1943         if ((active3 & 0x200000000000000L) != 0L)
1944            return jjStopAtPos(2, 249);
1945         break;
1946      default :
1947         break;
1948   }
1949   return jjStartNfa_5(1, 0L, 0L, 0L, active3);
1950}
1951private final int jjMoveNfa_5(int startState, int curPos)
1952{
1953   int[] nextStates;
1954   int startsAt = 0;
1955   jjnewStateCnt = 25;
1956   int i = 1;
1957   jjstateSet[0] = startState;
1958   int j, kind = 0x7fffffff;
1959   for (;;)
1960   {
1961      if (++jjround == 0x7fffffff)
1962         ReInitRounds();
1963      if (curChar < 64)
1964      {
1965         long l = 1L << curChar;
1966         MatchLoop: do
1967         {
1968            switch(jjstateSet[--i])
1969            {
1970               case 23:
1971                  if ((0xffffffff00002600L & l) != 0L)
1972                  {
1973                     if (kind > 250)
1974                        kind = 250;
1975                  }
1976                  if (curChar == 40)
1977                     jjstateSet[jjnewStateCnt++] = 22;
1978                  break;
1979               case 0:
1980                  if (curChar == 58)
1981                     jjCheckNAddTwoStates(4, 5);
1982                  break;
1983               case 1:
1984                  if (curChar == 58)
1985                     jjCheckNAddTwoStates(2, 21);
1986                  break;
1987               case 2:
1988                  if ((0xfbffffffffffffffL & l) != 0L)
1989                     jjCheckNAddTwoStates(2, 21);
1990                  break;
1991               case 3:
1992                  if (curChar == 41)
1993                     jjCheckNAddStates(0, 3);
1994                  break;
1995               case 4:
1996                  if (curChar == 40)
1997                     jjstateSet[jjnewStateCnt++] = 1;
1998                  break;
1999               case 5:
2000                  if ((0x100002600L & l) != 0L)
2001                     jjCheckNAddStates(0, 3);
2002                  break;
2003               case 21:
2004                  if (curChar == 58)
2005                     jjstateSet[jjnewStateCnt++] = 3;
2006                  break;
2007               case 22:
2008                  if (curChar == 58)
2009                     jjstateSet[jjnewStateCnt++] = 0;
2010                  break;
2011               case 24:
2012                  if ((0xffffffff00002600L & l) != 0L && kind > 250)
2013                     kind = 250;
2014                  break;
2015               default : break;
2016            }
2017         } while(i != startsAt);
2018      }
2019      else if (curChar < 128)
2020      {
2021         long l = 1L << (curChar & 077);
2022         MatchLoop: do
2023         {
2024            switch(jjstateSet[--i])
2025            {
2026               case 23:
2027                  if (kind > 250)
2028                     kind = 250;
2029                  break;
2030               case 2:
2031                  jjAddStates(4, 5);
2032                  break;
2033               case 6:
2034                  if (curChar == 97 && kind > 1)
2035                     kind = 1;
2036                  break;
2037               case 7:
2038                  if (curChar == 109)
2039                     jjstateSet[jjnewStateCnt++] = 6;
2040                  break;
2041               case 8:
2042                  if (curChar == 103)
2043                     jjstateSet[jjnewStateCnt++] = 7;
2044                  break;
2045               case 9:
2046                  if (curChar == 97)
2047                     jjstateSet[jjnewStateCnt++] = 8;
2048                  break;
2049               case 10:
2050                  if (curChar == 114)
2051                     jjstateSet[jjnewStateCnt++] = 9;
2052                  break;
2053               case 11:
2054                  if (curChar == 112)
2055                     jjstateSet[jjnewStateCnt++] = 10;
2056                  break;
2057               case 12:
2058                  if (curChar == 110 && kind > 1)
2059                     kind = 1;
2060                  break;
2061               case 13:
2062                  if (curChar == 111)
2063                     jjstateSet[jjnewStateCnt++] = 12;
2064                  break;
2065               case 14:
2066                  if (curChar == 105)
2067                     jjstateSet[jjnewStateCnt++] = 13;
2068                  break;
2069               case 15:
2070                  if (curChar == 115)
2071                     jjstateSet[jjnewStateCnt++] = 14;
2072                  break;
2073               case 16:
2074                  if (curChar == 110)
2075                     jjstateSet[jjnewStateCnt++] = 15;
2076                  break;
2077               case 17:
2078                  if (curChar == 101)
2079                     jjstateSet[jjnewStateCnt++] = 16;
2080                  break;
2081               case 18:
2082                  if (curChar == 116)
2083                     jjstateSet[jjnewStateCnt++] = 17;
2084                  break;
2085               case 19:
2086                  if (curChar == 120)
2087                     jjstateSet[jjnewStateCnt++] = 18;
2088                  break;
2089               case 20:
2090                  if (curChar == 101)
2091                     jjstateSet[jjnewStateCnt++] = 19;
2092                  break;
2093               default : break;
2094            }
2095         } while(i != startsAt);
2096      }
2097      else
2098      {
2099         int hiByte = (int)(curChar >> 8);
2100         int i1 = hiByte >> 6;
2101         long l1 = 1L << (hiByte & 077);
2102         int i2 = (curChar & 0xff) >> 6;
2103         long l2 = 1L << (curChar & 077);
2104         MatchLoop: do
2105         {
2106            switch(jjstateSet[--i])
2107            {
2108               case 23:
2109                  if (jjCanMove_3(hiByte, i1, i2, l1, l2) && kind > 250)
2110                     kind = 250;
2111                  break;
2112               case 2:
2113                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2114                     jjAddStates(4, 5);
2115                  break;
2116               default : break;
2117            }
2118         } while(i != startsAt);
2119      }
2120      if (kind != 0x7fffffff)
2121      {
2122         jjmatchedKind = kind;
2123         jjmatchedPos = curPos;
2124         kind = 0x7fffffff;
2125      }
2126      ++curPos;
2127      if ((i = jjnewStateCnt) == (startsAt = 25 - (jjnewStateCnt = startsAt)))
2128         return curPos;
2129      try { curChar = input_stream.readChar(); }
2130      catch(java.io.IOException JavaDoc e) { return curPos; }
2131   }
2132}
2133private final int jjStopStringLiteralDfa_15(int pos, long active0, long active1, long active2, long active3)
2134{
2135   switch (pos)
2136   {
2137      case 0:
2138         if ((active0 & 0x80000L) != 0L)
2139            return 22;
2140         return -1;
2141      case 1:
2142         if ((active0 & 0x80000L) != 0L)
2143            return 0;
2144         return -1;
2145      default :
2146         return -1;
2147   }
2148}
2149private final int jjStartNfa_15(int pos, long active0, long active1, long active2, long active3)
2150{
2151   return jjMoveNfa_15(jjStopStringLiteralDfa_15(pos, active0, active1, active2, active3), pos + 1);
2152}
2153private final int jjStartNfaWithStates_15(int pos, int kind, int state)
2154{
2155   jjmatchedKind = kind;
2156   jjmatchedPos = pos;
2157   try { curChar = input_stream.readChar(); }
2158   catch(java.io.IOException JavaDoc e) { return pos + 1; }
2159   return jjMoveNfa_15(state, pos + 1);
2160}
2161private final int jjMoveStringLiteralDfa0_15()
2162{
2163   switch(curChar)
2164   {
2165      case 36:
2166         return jjStopAtPos(0, 198);
2167      case 40:
2168         return jjMoveStringLiteralDfa1_15(0x80000L);
2169      case 123:
2170         return jjMoveStringLiteralDfa1_15(0x100000L);
2171      default :
2172         return jjMoveNfa_15(23, 0);
2173   }
2174}
2175private final int jjMoveStringLiteralDfa1_15(long active0)
2176{
2177   try { curChar = input_stream.readChar(); }
2178   catch(java.io.IOException JavaDoc e) {
2179      jjStopStringLiteralDfa_15(0, active0, 0L, 0L, 0L);
2180      return 1;
2181   }
2182   switch(curChar)
2183   {
2184      case 45:
2185         return jjMoveStringLiteralDfa2_15(active0, 0x100000L);
2186      case 58:
2187         if ((active0 & 0x80000L) != 0L)
2188            return jjStartNfaWithStates_15(1, 19, 0);
2189         break;
2190      default :
2191         break;
2192   }
2193   return jjStartNfa_15(0, active0, 0L, 0L, 0L);
2194}
2195private final int jjMoveStringLiteralDfa2_15(long old0, long active0)
2196{
2197   if (((active0 &= old0)) == 0L)
2198      return jjStartNfa_15(0, old0, 0L, 0L, 0L);
2199   try { curChar = input_stream.readChar(); }
2200   catch(java.io.IOException JavaDoc e) {
2201      jjStopStringLiteralDfa_15(1, active0, 0L, 0L, 0L);
2202      return 2;
2203   }
2204   switch(curChar)
2205   {
2206      case 45:
2207         if ((active0 & 0x100000L) != 0L)
2208            return jjStopAtPos(2, 20);
2209         break;
2210      default :
2211         break;
2212   }
2213   return jjStartNfa_15(1, active0, 0L, 0L, 0L);
2214}
2215private final int jjMoveNfa_15(int startState, int curPos)
2216{
2217   int[] nextStates;
2218   int startsAt = 0;
2219   jjnewStateCnt = 180;
2220   int i = 1;
2221   jjstateSet[0] = startState;
2222   int j, kind = 0x7fffffff;
2223   for (;;)
2224   {
2225      if (++jjround == 0x7fffffff)
2226         ReInitRounds();
2227      if (curChar < 64)
2228      {
2229         long l = 1L << curChar;
2230         MatchLoop: do
2231         {
2232            switch(jjstateSet[--i])
2233            {
2234               case 23:
2235                  if (curChar == 40)
2236                     jjstateSet[jjnewStateCnt++] = 22;
2237                  break;
2238               case 0:
2239                  if (curChar == 58)
2240                     jjCheckNAddTwoStates(4, 5);
2241                  break;
2242               case 1:
2243                  if (curChar == 58)
2244                     jjCheckNAddTwoStates(2, 21);
2245                  break;
2246               case 2:
2247                  if ((0xfbffffffffffffffL & l) != 0L)
2248                     jjCheckNAddTwoStates(2, 21);
2249                  break;
2250               case 3:
2251                  if (curChar == 41)
2252                     jjCheckNAddStates(0, 3);
2253                  break;
2254               case 4:
2255                  if (curChar == 40)
2256                     jjstateSet[jjnewStateCnt++] = 1;
2257                  break;
2258               case 5:
2259                  if ((0x100002600L & l) != 0L)
2260                     jjCheckNAddStates(0, 3);
2261                  break;
2262               case 21:
2263                  if (curChar == 58)
2264                     jjstateSet[jjnewStateCnt++] = 3;
2265                  break;
2266               case 22:
2267                  if (curChar == 58)
2268                     jjstateSet[jjnewStateCnt++] = 0;
2269                  break;
2270               case 25:
2271                  if (curChar == 58)
2272                     jjCheckNAddTwoStates(26, 31);
2273                  break;
2274               case 26:
2275                  if ((0xfbffffffffffffffL & l) != 0L)
2276                     jjCheckNAddTwoStates(26, 31);
2277                  break;
2278               case 27:
2279                  if (curChar == 41)
2280                     jjCheckNAddStates(11, 13);
2281                  break;
2282               case 28:
2283                  if (curChar == 40)
2284                     jjstateSet[jjnewStateCnt++] = 25;
2285                  break;
2286               case 29:
2287                  if ((0x100002600L & l) != 0L)
2288                     jjCheckNAddStates(11, 13);
2289                  break;
2290               case 30:
2291                  if (curChar == 40 && kind > 26)
2292                     kind = 26;
2293                  break;
2294               case 31:
2295                  if (curChar == 58)
2296                     jjstateSet[jjnewStateCnt++] = 27;
2297                  break;
2298               case 41:
2299                  if (curChar == 58)
2300                     jjCheckNAddTwoStates(42, 47);
2301                  break;
2302               case 42:
2303                  if ((0xfbffffffffffffffL & l) != 0L)
2304                     jjCheckNAddTwoStates(42, 47);
2305                  break;
2306               case 43:
2307                  if (curChar == 41)
2308                     jjCheckNAddStates(28, 30);
2309                  break;
2310               case 44:
2311                  if (curChar == 40)
2312                     jjstateSet[jjnewStateCnt++] = 41;
2313                  break;
2314               case 45:
2315                  if ((0x100002600L & l) != 0L)
2316                     jjCheckNAddStates(28, 30);
2317                  break;
2318               case 46:
2319                  if (curChar == 40 && kind > 27)
2320                     kind = 27;
2321                  break;
2322               case 47:
2323                  if (curChar == 58)
2324                     jjstateSet[jjnewStateCnt++] = 43;
2325                  break;
2326               case 55:
2327                  if (curChar == 58)
2328                     jjCheckNAddTwoStates(56, 61);
2329                  break;
2330               case 56:
2331                  if ((0xfbffffffffffffffL & l) != 0L)
2332                     jjCheckNAddTwoStates(56, 61);
2333                  break;
2334               case 57:
2335                  if (curChar == 41)
2336                     jjCheckNAddStates(31, 33);
2337                  break;
2338               case 58:
2339                  if (curChar == 40)
2340                     jjstateSet[jjnewStateCnt++] = 55;
2341                  break;
2342               case 59:
2343                  if ((0x100002600L & l) != 0L)
2344                     jjCheckNAddStates(31, 33);
2345                  break;
2346               case 60:
2347                  if (curChar == 40 && kind > 28)
2348                     kind = 28;
2349                  break;
2350               case 61:
2351                  if (curChar == 58)
2352                     jjstateSet[jjnewStateCnt++] = 57;
2353                  break;
2354               case 66:
2355                  if (curChar == 58)
2356                     jjCheckNAddTwoStates(67, 72);
2357                  break;
2358               case 67:
2359                  if ((0xfbffffffffffffffL & l) != 0L)
2360                     jjCheckNAddTwoStates(67, 72);
2361                  break;
2362               case 68:
2363                  if (curChar == 41)
2364                     jjCheckNAddStates(34, 36);
2365                  break;
2366               case 69:
2367                  if (curChar == 40)
2368                     jjstateSet[jjnewStateCnt++] = 66;
2369                  break;
2370               case 70:
2371                  if ((0x100002600L & l) != 0L)
2372                     jjCheckNAddStates(34, 36);
2373                  break;
2374               case 71:
2375                  if (curChar == 40 && kind > 29)
2376                     kind = 29;
2377                  break;
2378               case 72:
2379                  if (curChar == 58)
2380                     jjstateSet[jjnewStateCnt++] = 68;
2381                  break;
2382               case 77:
2383                  if (curChar == 58)
2384                     jjCheckNAddTwoStates(78, 83);
2385                  break;
2386               case 78:
2387                  if ((0xfbffffffffffffffL & l) != 0L)
2388                     jjCheckNAddTwoStates(78, 83);
2389                  break;
2390               case 79:
2391                  if (curChar == 41)
2392                     jjCheckNAddStates(37, 39);
2393                  break;
2394               case 80:
2395                  if (curChar == 40)
2396                     jjstateSet[jjnewStateCnt++] = 77;
2397                  break;
2398               case 81:
2399                  if ((0x100002600L & l) != 0L)
2400                     jjCheckNAddStates(37, 39);
2401                  break;
2402               case 82:
2403                  if (curChar == 40 && kind > 30)
2404                     kind = 30;
2405                  break;
2406               case 83:
2407                  if (curChar == 58)
2408                     jjstateSet[jjnewStateCnt++] = 79;
2409                  break;
2410               case 87:
2411                  if (curChar == 45)
2412                     jjstateSet[jjnewStateCnt++] = 86;
2413                  break;
2414               case 97:
2415                  if (curChar == 58)
2416                     jjCheckNAddTwoStates(98, 103);
2417                  break;
2418               case 98:
2419                  if ((0xfbffffffffffffffL & l) != 0L)
2420                     jjCheckNAddTwoStates(98, 103);
2421                  break;
2422               case 99:
2423                  if (curChar == 41)
2424                     jjCheckNAddStates(40, 42);
2425                  break;
2426               case 100:
2427                  if (curChar == 40)
2428                     jjstateSet[jjnewStateCnt++] = 97;
2429                  break;
2430               case 101:
2431                  if ((0x100002600L & l) != 0L)
2432                     jjCheckNAddStates(40, 42);
2433                  break;
2434               case 102:
2435                  if (curChar == 40 && kind > 31)
2436                     kind = 31;
2437                  break;
2438               case 103:
2439                  if (curChar == 58)
2440                     jjstateSet[jjnewStateCnt++] = 99;
2441                  break;
2442               case 114:
2443                  if (curChar == 45)
2444                     jjstateSet[jjnewStateCnt++] = 113;
2445                  break;
2446               case 126:
2447                  if (curChar == 58)
2448                     jjCheckNAddTwoStates(127, 139);
2449                  break;
2450               case 127:
2451                  if ((0xfbffffffffffffffL & l) != 0L)
2452                     jjCheckNAddTwoStates(127, 139);
2453                  break;
2454               case 128:
2455                  if (curChar == 41)
2456                     jjCheckNAddStates(43, 45);
2457                  break;
2458               case 129:
2459                  if (curChar == 40)
2460                     jjstateSet[jjnewStateCnt++] = 126;
2461                  break;
2462               case 130:
2463                  if ((0x100002600L & l) != 0L)
2464                     jjCheckNAddStates(43, 45);
2465                  break;
2466               case 131:
2467                  if (curChar == 40)
2468                     jjCheckNAddStates(46, 48);
2469                  break;
2470               case 132:
2471                  if (curChar == 58)
2472                     jjCheckNAddTwoStates(133, 138);
2473                  break;
2474               case 133:
2475                  if ((0xfbffffffffffffffL & l) != 0L)
2476                     jjCheckNAddTwoStates(133, 138);
2477                  break;
2478               case 134:
2479                  if (curChar == 41)
2480                     jjCheckNAddStates(46, 48);
2481                  break;
2482               case 135:
2483                  if (curChar == 40)
2484                     jjstateSet[jjnewStateCnt++] = 132;
2485                  break;
2486               case 136:
2487                  if ((0x100002600L & l) != 0L)
2488                     jjCheckNAddStates(46, 48);
2489                  break;
2490               case 137:
2491                  if (curChar == 41 && kind > 201)
2492                     kind = 201;
2493                  break;
2494               case 138:
2495                  if (curChar == 58)
2496                     jjstateSet[jjnewStateCnt++] = 134;
2497                  break;
2498               case 139:
2499                  if (curChar == 58)
2500                     jjstateSet[jjnewStateCnt++] = 128;
2501                  break;
2502               case 144:
2503                  if ((0x3ff600000000000L & l) != 0L)
2504                     jjAddStates(49, 50);
2505                  break;
2506               case 145:
2507                  if (curChar == 58)
2508                     jjstateSet[jjnewStateCnt++] = 146;
2509                  break;
2510               case 147:
2511                  if ((0x3ff600000000000L & l) == 0L)
2512                     break;
2513                  if (kind > 200)
2514                     kind = 200;
2515                  jjstateSet[jjnewStateCnt++] = 147;
2516                  break;
2517               case 150:
2518                  if (curChar == 58)
2519                     jjCheckNAddTwoStates(151, 156);
2520                  break;
2521               case 151:
2522                  if ((0xfbffffffffffffffL & l) != 0L)
2523                     jjCheckNAddTwoStates(151, 156);
2524                  break;
2525               case 152:
2526                  if (curChar == 41)
2527                     jjCheckNAddStates(51, 53);
2528                  break;
2529               case 153:
2530                  if (curChar == 40)
2531                     jjstateSet[jjnewStateCnt++] = 150;
2532                  break;
2533               case 154:
2534                  if ((0x100002600L & l) != 0L)
2535                     jjCheckNAddStates(51, 53);
2536                  break;
2537               case 155:
2538                  if (curChar == 40 && kind > 25)
2539                     kind = 25;
2540                  break;
2541               case 156:
2542                  if (curChar == 58)
2543                     jjstateSet[jjnewStateCnt++] = 152;
2544                  break;
2545               case 163:
2546                  if (curChar == 58)
2547                     jjCheckNAddTwoStates(164, 176);
2548                  break;
2549               case 164:
2550                  if ((0xfbffffffffffffffL & l) != 0L)
2551                     jjCheckNAddTwoStates(164, 176);
2552                  break;
2553               case 165:
2554                  if (curChar == 41)
2555                     jjCheckNAddStates(54, 56);
2556                  break;
2557               case 166:
2558                  if (curChar == 40)
2559                     jjstateSet[jjnewStateCnt++] = 163;
2560                  break;
2561               case 167:
2562                  if ((0x100002600L & l) != 0L)
2563                     jjCheckNAddStates(54, 56);
2564                  break;
2565               case 168:
2566                  if (curChar == 40)
2567                     jjCheckNAddStates(57, 59);
2568                  break;
2569               case 169:
2570                  if (curChar == 58)
2571                     jjCheckNAddTwoStates(170, 175);
2572                  break;
2573               case 170:
2574                  if ((0xfbffffffffffffffL & l) != 0L)
2575                     jjCheckNAddTwoStates(170, 175);
2576                  break;
2577               case 171:
2578                  if (curChar == 41)
2579                     jjCheckNAddStates(57, 59);
2580                  break;
2581               case 172:
2582                  if (curChar == 40)
2583                     jjstateSet[jjnewStateCnt++] = 169;
2584                  break;
2585               case 173:
2586                  if ((0x100002600L & l) != 0L)
2587                     jjCheckNAddStates(57, 59);
2588                  break;
2589               case 174:
2590                  if (curChar == 41 && kind > 199)
2591                     kind = 199;
2592                  break;
2593               case 175:
2594                  if (curChar == 58)
2595                     jjstateSet[jjnewStateCnt++] = 171;
2596                  break;
2597               case 176:
2598                  if (curChar == 58)
2599                     jjstateSet[jjnewStateCnt++] = 165;
2600                  break;
2601               default : break;
2602            }
2603         } while(i != startsAt);
2604      }
2605      else if (curChar < 128)
2606      {
2607         long l = 1L << (curChar & 077);
2608         MatchLoop: do
2609         {
2610            switch(jjstateSet[--i])
2611            {
2612               case 23:
2613                  if ((0x7fffffe87fffffeL & l) != 0L)
2614                  {
2615                     if (kind > 200)
2616                        kind = 200;
2617                     jjCheckNAddStates(60, 62);
2618                  }
2619                  if (curChar == 101)
2620                     jjAddStates(63, 64);
2621                  else if (curChar == 105)
2622                     jjstateSet[jjnewStateCnt++] = 141;
2623                  else if (curChar == 112)
2624                     jjstateSet[jjnewStateCnt++] = 123;
2625                  else if (curChar == 100)
2626                     jjstateSet[jjnewStateCnt++] = 94;
2627                  else if (curChar == 110)
2628                     jjstateSet[jjnewStateCnt++] = 74;
2629                  else if (curChar == 116)
2630                     jjstateSet[jjnewStateCnt++] = 63;
2631                  else if (curChar == 99)
2632                     jjstateSet[jjnewStateCnt++] = 52;
2633                  else if (curChar == 97)
2634                     jjstateSet[jjnewStateCnt++] = 38;
2635                  break;
2636               case 2:
2637                  jjAddStates(4, 5);
2638                  break;
2639               case 6:
2640                  if (curChar == 97 && kind > 1)
2641                     kind = 1;
2642                  break;
2643               case 7:
2644                  if (curChar == 109)
2645                     jjstateSet[jjnewStateCnt++] = 6;
2646                  break;
2647               case 8:
2648                  if (curChar == 103)
2649                     jjstateSet[jjnewStateCnt++] = 7;
2650                  break;
2651               case 9:
2652                  if (curChar == 97)
2653                     jjstateSet[jjnewStateCnt++] = 8;
2654                  break;
2655               case 10:
2656                  if (curChar == 114)
2657                     jjstateSet[jjnewStateCnt++] = 9;
2658                  break;
2659               case 11:
2660                  if (curChar == 112)
2661                     jjstateSet[jjnewStateCnt++] = 10;
2662                  break;
2663               case 12:
2664                  if (curChar == 110 && kind > 1)
2665                     kind = 1;
2666                  break;
2667               case 13:
2668                  if (curChar == 111)
2669                     jjstateSet[jjnewStateCnt++] = 12;
2670                  break;
2671               case 14:
2672                  if (curChar == 105)
2673                     jjstateSet[jjnewStateCnt++] = 13;
2674                  break;
2675               case 15:
2676                  if (curChar == 115)
2677                     jjstateSet[jjnewStateCnt++] = 14;
2678                  break;
2679               case 16:
2680                  if (curChar == 110)
2681                     jjstateSet[jjnewStateCnt++] = 15;
2682                  break;
2683               case 17:
2684                  if (curChar == 101)
2685                     jjstateSet[jjnewStateCnt++] = 16;
2686                  break;
2687               case 18:
2688                  if (curChar == 116)
2689                     jjstateSet[jjnewStateCnt++] = 17;
2690                  break;
2691               case 19:
2692                  if (curChar == 120)
2693                     jjstateSet[jjnewStateCnt++] = 18;
2694                  break;
2695               case 20:
2696                  if (curChar == 101)
2697                     jjstateSet[jjnewStateCnt++] = 19;
2698                  break;
2699               case 24:
2700                  if (curChar == 101)
2701                     jjAddStates(11, 13);
2702                  break;
2703               case 26:
2704                  jjAddStates(20, 21);
2705                  break;
2706               case 32:
2707                  if (curChar == 116)
2708                     jjstateSet[jjnewStateCnt++] = 24;
2709                  break;
2710               case 33:
2711                  if (curChar == 117)
2712                     jjstateSet[jjnewStateCnt++] = 32;
2713                  break;
2714               case 34:
2715                  if (curChar == 98)
2716                     jjstateSet[jjnewStateCnt++] = 33;
2717                  break;
2718               case 35:
2719                  if (curChar == 105)
2720                     jjstateSet[jjnewStateCnt++] = 34;
2721                  break;
2722               case 36:
2723                  if (curChar == 114)
2724                     jjstateSet[jjnewStateCnt++] = 35;
2725                  break;
2726               case 37:
2727                  if (curChar == 116)
2728                     jjstateSet[jjnewStateCnt++] = 36;
2729                  break;
2730               case 38:
2731                  if (curChar == 116)
2732                     jjstateSet[jjnewStateCnt++] = 37;
2733                  break;
2734               case 39:
2735                  if (curChar == 97)
2736                     jjstateSet[jjnewStateCnt++] = 38;
2737                  break;
2738               case 40:
2739                  if (curChar == 116)
2740                     jjAddStates(28, 30);
2741                  break;
2742               case 42:
2743                  jjAddStates(65, 66);
2744                  break;
2745               case 48:
2746                  if (curChar == 110)
2747                     jjstateSet[jjnewStateCnt++] = 40;
2748                  break;
2749               case 49:
2750                  if (curChar == 101)
2751                     jjstateSet[jjnewStateCnt++] = 48;
2752                  break;
2753               case 50:
2754                  if (curChar == 109)
2755                     jjstateSet[jjnewStateCnt++] = 49;
2756                  break;
2757               case 51:
2758                  if (curChar == 109)
2759                     jjstateSet[jjnewStateCnt++] = 50;
2760                  break;
2761               case 52:
2762                  if (curChar == 111)
2763                     jjstateSet[jjnewStateCnt++] = 51;
2764                  break;
2765               case 53:
2766                  if (curChar == 99)
2767                     jjstateSet[jjnewStateCnt++] = 52;
2768                  break;
2769               case 54:
2770                  if (curChar == 116)
2771                     jjAddStates(31, 33);
2772                  break;
2773               case 56:
2774                  jjAddStates(67, 68);
2775                  break;
2776               case 62:
2777                  if (curChar == 120)
2778                     jjstateSet[jjnewStateCnt++] = 54;
2779                  break;
2780               case 63:
2781                  if (curChar == 101)
2782                     jjstateSet[jjnewStateCnt++] = 62;
2783                  break;
2784               case 64:
2785                  if (curChar == 116)
2786                     jjstateSet[jjnewStateCnt++] = 63;
2787                  break;
2788               case 65:
2789                  if (curChar == 101)
2790                     jjAddStates(34, 36);
2791                  break;
2792               case 67:
2793                  jjAddStates(69, 70);
2794                  break;
2795               case 73:
2796                  if (curChar == 100)
2797                     jjstateSet[jjnewStateCnt++] = 65;
2798                  break;
2799               case 74:
2800                  if (curChar == 111)
2801                     jjstateSet[jjnewStateCnt++] = 73;
2802                  break;
2803               case 75:
2804                  if (curChar == 110)
2805                     jjstateSet[jjnewStateCnt++] = 74;
2806                  break;
2807               case 76:
2808                  if (curChar == 101)
2809                     jjAddStates(37, 39);
2810                  break;
2811               case 78:
2812                  jjAddStates(71, 72);
2813                  break;
2814               case 84:
2815                  if (curChar == 100)
2816                     jjstateSet[jjnewStateCnt++] = 76;
2817                  break;
2818               case 85:
2819                  if (curChar == 111)
2820                     jjstateSet[jjnewStateCnt++] = 84;
2821                  break;
2822               case 86:
2823                  if (curChar == 110)
2824                     jjstateSet[jjnewStateCnt++] = 85;
2825                  break;
2826               case 88:
2827                  if (curChar == 116)
2828                     jjstateSet[jjnewStateCnt++] = 87;
2829                  break;
2830               case 89:
2831                  if (curChar == 110)
2832                     jjstateSet[jjnewStateCnt++] = 88;
2833                  break;
2834               case 90:
2835                  if (curChar == 101)
2836                     jjstateSet[jjnewStateCnt++] = 89;
2837                  break;
2838               case 91:
2839                  if (curChar == 109)
2840                     jjstateSet[jjnewStateCnt++] = 90;
2841                  break;
2842               case 92:
2843                  if (curChar == 117)
2844                     jjstateSet[jjnewStateCnt++] = 91;
2845                  break;
2846               case 93:
2847                  if (curChar == 99)
2848                     jjstateSet[jjnewStateCnt++] = 92;
2849                  break;
2850               case 94:
2851                  if (curChar == 111)
2852                     jjstateSet[jjnewStateCnt++] = 93;
2853                  break;
2854               case 95:
2855                  if (curChar == 100)
2856                     jjstateSet[jjnewStateCnt++] = 94;
2857                  break;
2858               case 96:
2859                  if (curChar == 110)
2860                     jjAddStates(40, 42);
2861                  break;
2862               case 98:
2863                  jjAddStates(73, 74);
2864                  break;
2865               case 104:
2866                  if (curChar == 111)
2867                     jjstateSet[jjnewStateCnt++] = 96;
2868                  break;
2869               case 105:
2870                  if (curChar == 105)
2871                     jjstateSet[jjnewStateCnt++] = 104;
2872                  break;
2873               case 106:
2874                  if (curChar == 116)
2875                     jjstateSet[jjnewStateCnt++] = 105;
2876                  break;
2877               case 107:
2878                  if (curChar == 99)
2879                     jjstateSet[jjnewStateCnt++] = 106;
2880                  break;
2881               case 108:
2882                  if (curChar == 117)
2883                     jjstateSet[jjnewStateCnt++] = 107;
2884                  break;
2885               case 109:
2886                  if (curChar == 114)
2887                     jjstateSet[jjnewStateCnt++] = 108;
2888                  break;
2889               case 110:
2890                  if (curChar == 116)
2891                     jjstateSet[jjnewStateCnt++] = 109;
2892                  break;
2893               case 111:
2894                  if (curChar == 115)
2895                     jjstateSet[jjnewStateCnt++] = 110;
2896                  break;
2897               case 112:
2898                  if (curChar == 110)
2899                     jjstateSet[jjnewStateCnt++] = 111;
2900                  break;
2901               case 113:
2902                  if (curChar == 105)
2903                     jjstateSet[jjnewStateCnt++] = 112;
2904                  break;
2905               case 115:
2906                  if (curChar == 103)
2907                     jjstateSet[jjnewStateCnt++] = 114;
2908                  break;
2909               case 116:
2910                  if (curChar == 110)
2911                     jjstateSet[jjnewStateCnt++] = 115;
2912                  break;
2913               case 117:
2914                  if (curChar == 105)
2915                     jjstateSet[jjnewStateCnt++] = 116;
2916                  break;
2917               case 118:
2918                  if (curChar == 115)
2919                     jjstateSet[jjnewStateCnt++] = 117;
2920                  break;
2921               case 119:
2922                  if (curChar == 115)
2923                     jjstateSet[jjnewStateCnt++] = 118;
2924                  break;
2925               case 120:
2926                  if (curChar == 101)
2927                     jjstateSet[jjnewStateCnt++] = 119;
2928                  break;
2929               case 121:
2930                  if (curChar == 99)
2931                     jjstateSet[jjnewStateCnt++] = 120;
2932                  break;
2933               case 122:
2934                  if (curChar == 111)
2935                     jjstateSet[jjnewStateCnt++] = 121;
2936                  break;
2937               case 123:
2938                  if (curChar == 114)
2939                     jjstateSet[jjnewStateCnt++] = 122;
2940                  break;
2941               case 124:
2942                  if (curChar == 112)
2943                     jjstateSet[jjnewStateCnt++] = 123;
2944                  break;
2945               case 125:
2946                  if (curChar == 109)
2947                     jjAddStates(43, 45);
2948                  break;
2949               case 127:
2950                  jjAddStates(75, 76);
2951                  break;
2952               case 133:
2953                  jjAddStates(77, 78);
2954                  break;
2955               case 140:
2956                  if (curChar == 101)
2957                     jjstateSet[jjnewStateCnt++] = 125;
2958                  break;
2959               case 141:
2960                  if (curChar == 116)
2961                     jjstateSet[jjnewStateCnt++] = 140;
2962                  break;
2963               case 142:
2964                  if (curChar == 105)
2965                     jjstateSet[jjnewStateCnt++] = 141;
2966                  break;
2967               case 143:
2968                  if ((0x7fffffe87fffffeL & l) == 0L)
2969                     break;
2970                  if (kind > 200)
2971                     kind = 200;
2972                  jjCheckNAddStates(60, 62);
2973                  break;
2974               case 144:
2975                  if ((0x7fffffe87fffffeL & l) != 0L)
2976                     jjCheckNAddTwoStates(144, 145);
2977                  break;
2978               case 146:
2979               case 147:
2980                  if ((0x7fffffe87fffffeL & l) == 0L)
2981                     break;
2982                  if (kind > 200)
2983                     kind = 200;
2984                  jjCheckNAdd(147);
2985                  break;
2986               case 148:
2987                  if (curChar == 101)
2988                     jjAddStates(63, 64);
2989                  break;
2990               case 149:
2991                  if (curChar == 116)
2992                     jjAddStates(51, 53);
2993                  break;
2994               case 151:
2995                  jjAddStates(79, 80);
2996                  break;
2997               case 157:
2998                  if (curChar == 110)
2999                     jjstateSet[jjnewStateCnt++] = 149;
3000                  break;
3001               case 158:
3002                  if (curChar == 101)
3003                     jjstateSet[jjnewStateCnt++] = 157;
3004                  break;
3005               case 159:
3006                  if (curChar == 109)
3007                     jjstateSet[jjnewStateCnt++] = 158;
3008                  break;
3009               case 160:
3010                  if (curChar == 101)
3011                     jjstateSet[jjnewStateCnt++] = 159;
3012                  break;
3013               case 161:
3014                  if (curChar == 108)
3015                     jjstateSet[jjnewStateCnt++] = 160;
3016                  break;
3017               case 162:
3018                  if (curChar == 121)
3019                     jjAddStates(54, 56);
3020                  break;
3021               case 164:
3022                  jjAddStates(81, 82);
3023                  break;
3024               case 170:
3025                  jjAddStates(83, 84);
3026                  break;
3027               case 177:
3028                  if (curChar == 116)
3029                     jjstateSet[jjnewStateCnt++] = 162;
3030                  break;
3031               case 178:
3032                  if (curChar == 112)
3033                     jjstateSet[jjnewStateCnt++] = 177;
3034                  break;
3035               case 179:
3036                  if (curChar == 109)
3037                     jjstateSet[jjnewStateCnt++] = 178;
3038                  break;
3039               default : break;
3040            }
3041         } while(i != startsAt);
3042      }
3043      else
3044      {
3045         int hiByte = (int)(curChar >> 8);
3046         int i1 = hiByte >> 6;
3047         long l1 = 1L << (hiByte & 077);
3048         int i2 = (curChar & 0xff) >> 6;
3049         long l2 = 1L << (curChar & 077);
3050         MatchLoop: do
3051         {
3052            switch(jjstateSet[--i])
3053            {
3054               case 23:
3055                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3056                     break;
3057                  if (kind > 200)
3058                     kind = 200;
3059                  jjCheckNAddStates(60, 62);
3060                  break;
3061               case 2:
3062                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3063                     jjAddStates(4, 5);
3064                  break;
3065               case 26:
3066                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3067                     jjAddStates(20, 21);
3068                  break;
3069               case 42:
3070                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3071                     jjAddStates(65, 66);
3072                  break;
3073               case 56:
3074                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3075                     jjAddStates(67, 68);
3076                  break;
3077               case 67:
3078                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3079                     jjAddStates(69, 70);
3080                  break;
3081               case 78:
3082                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3083                     jjAddStates(71, 72);
3084                  break;
3085               case 98:
3086                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3087                     jjAddStates(73, 74);
3088                  break;
3089               case 127:
3090                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3091                     jjAddStates(75, 76);
3092                  break;
3093               case 133:
3094                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3095                     jjAddStates(77, 78);
3096                  break;
3097               case 144:
3098                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
3099                     jjCheckNAddTwoStates(144, 145);
3100                  break;
3101               case 146:
3102                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3103                     break;
3104                  if (kind > 200)
3105                     kind = 200;
3106                  jjCheckNAdd(147);
3107                  break;
3108               case 147:
3109                  if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
3110                     break;
3111                  if (kind > 200)
3112                     kind = 200;
3113                  jjCheckNAdd(147);
3114                  break;
3115               case 151:
3116                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3117                     jjAddStates(79, 80);
3118                  break;
3119               case 164:
3120                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3121                     jjAddStates(81, 82);
3122                  break;
3123               case 170:
3124                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3125                     jjAddStates(83, 84);
3126                  break;
3127               default : break;
3128            }
3129         } while(i != startsAt);
3130      }
3131      if (kind != 0x7fffffff)
3132      {
3133         jjmatchedKind = kind;
3134         jjmatchedPos = curPos;
3135         kind = 0x7fffffff;
3136      }
3137      ++curPos;
3138      if ((i = jjnewStateCnt) == (startsAt = 180 - (jjnewStateCnt = startsAt)))
3139         return curPos;
3140      try { curChar = input_stream.readChar(); }
3141      catch(java.io.IOException JavaDoc e) { return curPos; }
3142   }
3143}
3144private final int jjStopStringLiteralDfa_8(int pos, long active0, long active1, long active2, long active3)
3145{
3146   switch (pos)
3147   {
3148      default :
3149         return -1;
3150   }
3151}
3152private final int jjStartNfa_8(int pos, long active0, long active1, long active2, long active3)
3153{
3154   return jjMoveNfa_8(jjStopStringLiteralDfa_8(pos, active0, active1, active2, active3), pos + 1);
3155}
3156private final int jjStartNfaWithStates_8(int pos, int kind, int state)
3157{
3158   jjmatchedKind = kind;
3159   jjmatchedPos = pos;
3160   try { curChar = input_stream.readChar(); }
3161   catch(java.io.IOException JavaDoc e) { return pos + 1; }
3162   return jjMoveNfa_8(state, pos + 1);
3163}
3164private final int jjMoveStringLiteralDfa0_8()
3165{
3166   switch(curChar)
3167   {
3168      case 60:
3169         jjmatchedKind = 230;
3170         return jjMoveStringLiteralDfa1_8(0xf0000000000L);
3171      case 123:
3172         jjmatchedKind = 231;
3173         return jjMoveStringLiteralDfa1_8(0x100000000000L);
3174      case 125:
3175         return jjMoveStringLiteralDfa1_8(0x200000000000L);
3176      default :
3177         return jjMoveNfa_8(23, 0);
3178   }
3179}
3180private final int jjMoveStringLiteralDfa1_8(long active3)
3181{
3182   try { curChar = input_stream.readChar(); }
3183   catch(java.io.IOException JavaDoc e) {
3184      jjStopStringLiteralDfa_8(0, 0L, 0L, 0L, active3);
3185      return 1;
3186   }
3187   switch(curChar)
3188   {
3189      case 33:
3190         return jjMoveStringLiteralDfa2_8(active3, 0xa0000000000L);
3191      case 47:
3192         if ((active3 & 0x10000000000L) != 0L)
3193            return jjStopAtPos(1, 232);
3194         break;
3195      case 63:
3196         if ((active3 & 0x40000000000L) != 0L)
3197            return jjStopAtPos(1, 234);
3198         break;
3199      case 123:
3200         if ((active3 & 0x100000000000L) != 0L)
3201            return jjStopAtPos(1, 236);
3202         break;
3203      case 125:
3204         if ((active3 & 0x200000000000L) != 0L)
3205            return jjStopAtPos(1, 237);
3206         break;
3207      default :
3208         break;
3209   }
3210   return jjStartNfa_8(0, 0L, 0L, 0L, active3);
3211}
3212private final int jjMoveStringLiteralDfa2_8(long old3, long active3)
3213{
3214   if (((active3 &= old3)) == 0L)
3215      return jjStartNfa_8(0, 0L, 0L, 0L, old3);
3216   try { curChar = input_stream.readChar(); }
3217   catch(java.io.IOException JavaDoc e) {
3218      jjStopStringLiteralDfa_8(1, 0L, 0L, 0L, active3);
3219      return 2;
3220   }
3221   switch(curChar)
3222   {
3223      case 45:
3224         return jjMoveStringLiteralDfa3_8(active3, 0x20000000000L);
3225      case 91:
3226         return jjMoveStringLiteralDfa3_8(active3, 0x80000000000L);
3227      default :
3228         break;
3229   }
3230   return jjStartNfa_8(1, 0L, 0L, 0L, active3);
3231}
3232private final int jjMoveStringLiteralDfa3_8(long old3, long active3)
3233{
3234   if (((active3 &= old3)) == 0L)
3235      return jjStartNfa_8(1, 0L, 0L, 0L, old3);
3236   try { curChar = input_stream.readChar(); }
3237   catch(java.io.IOException JavaDoc e) {
3238      jjStopStringLiteralDfa_8(2, 0L, 0L, 0L, active3);
3239      return 3;
3240   }
3241   switch(curChar)
3242   {
3243      case 45:
3244         if ((active3 & 0x20000000000L) != 0L)
3245            return jjStopAtPos(3, 233);
3246         break;
3247      case 67:
3248         return jjMoveStringLiteralDfa4_8(active3, 0x80000000000L);
3249      default :
3250         break;
3251   }
3252   return jjStartNfa_8(2, 0L, 0L, 0L, active3);
3253}
3254private final int jjMoveStringLiteralDfa4_8(long old3, long active3)
3255{
3256   if (((active3 &= old3)) == 0L)
3257      return jjStartNfa_8(2, 0L, 0L, 0L, old3);
3258   try { curChar = input_stream.readChar(); }
3259   catch(java.io.IOException JavaDoc e) {
3260      jjStopStringLiteralDfa_8(3, 0L, 0L, 0L, active3);
3261      return 4;
3262   }
3263   switch(curChar)
3264   {
3265      case 68:
3266         return jjMoveStringLiteralDfa5_8(active3, 0x80000000000L);
3267      default :
3268         break;
3269   }
3270   return jjStartNfa_8(3, 0L, 0L, 0L, active3);
3271}
3272private final int jjMoveStringLiteralDfa5_8(long old3, long active3)
3273{
3274   if (((active3 &= old3)) == 0L)
3275      return jjStartNfa_8(3, 0L, 0L, 0L, old3);
3276   try { curChar = input_stream.readChar(); }
3277   catch(java.io.IOException JavaDoc e) {
3278      jjStopStringLiteralDfa_8(4, 0L, 0L, 0L, active3);
3279      return 5;
3280   }
3281   switch(curChar)
3282   {
3283      case 65:
3284         return jjMoveStringLiteralDfa6_8(active3, 0x80000000000L);
3285      default :
3286         break;
3287   }
3288   return jjStartNfa_8(4, 0L, 0L, 0L, active3);
3289}
3290private final int jjMoveStringLiteralDfa6_8(long old3, long active3)
3291{
3292   if (((active3 &= old3)) == 0L)
3293      return jjStartNfa_8(4, 0L, 0L, 0L, old3);
3294   try { curChar = input_stream.readChar(); }
3295   catch(java.io.IOException JavaDoc e) {
3296      jjStopStringLiteralDfa_8(5, 0L, 0L, 0L, active3);
3297      return 6;
3298   }
3299   switch(curChar)
3300   {
3301      case 84:
3302         return jjMoveStringLiteralDfa7_8(active3, 0x80000000000L);
3303      default :
3304         break;
3305   }
3306   return jjStartNfa_8(5, 0L, 0L, 0L, active3);
3307}
3308private final int jjMoveStringLiteralDfa7_8(long old3, long active3)
3309{
3310   if (((active3 &= old3)) == 0L)
3311      return jjStartNfa_8(5, 0L, 0L, 0L, old3);
3312   try { curChar = input_stream.readChar(); }
3313   catch(java.io.IOException JavaDoc e) {
3314      jjStopStringLiteralDfa_8(6, 0L, 0L, 0L, active3);
3315      return 7;
3316   }
3317   switch(curChar)
3318   {
3319      case 65:
3320         return jjMoveStringLiteralDfa8_8(active3, 0x80000000000L);
3321      default :
3322         break;
3323   }
3324   return jjStartNfa_8(6, 0L, 0L, 0L, active3);
3325}
3326private final int jjMoveStringLiteralDfa8_8(long old3, long active3)
3327{
3328   if (((active3 &= old3)) == 0L)
3329      return jjStartNfa_8(6, 0L, 0L, 0L, old3);
3330   try { curChar = input_stream.readChar(); }
3331   catch(java.io.IOException JavaDoc e) {
3332      jjStopStringLiteralDfa_8(7, 0L, 0L, 0L, active3);
3333      return 8;
3334   }
3335   switch(curChar)
3336   {
3337      case 91:
3338         if ((active3 & 0x80000000000L) != 0L)
3339            return jjStopAtPos(8, 235);
3340         break;
3341      default :
3342         break;
3343   }
3344   return jjStartNfa_8(7, 0L, 0L, 0L, active3);
3345}
3346private final int jjMoveNfa_8(int startState, int curPos)
3347{
3348   int[] nextStates;
3349   int startsAt = 0;
3350   jjnewStateCnt = 46;
3351   int i = 1;
3352   jjstateSet[0] = startState;
3353   int j, kind = 0x7fffffff;
3354   for (;;)
3355   {
3356      if (++jjround == 0x7fffffff)
3357         ReInitRounds();
3358      if (curChar < 64)
3359      {
3360         long l = 1L << curChar;
3361         MatchLoop: do
3362         {
3363            switch(jjstateSet[--i])
3364            {
3365               case 23:
3366                  if ((0xefffffbfffffffffL & l) != 0L)
3367                  {
3368                     if (kind > 241)
3369                        kind = 241;
3370                  }
3371                  else if (curChar == 38)
3372                     jjstateSet[jjnewStateCnt++] = 38;
3373                  if ((0x100002600L & l) != 0L)
3374                  {
3375                     if (kind > 240)
3376                        kind = 240;
3377                  }
3378                  else if (curChar == 38)
3379                     jjAddStates(85, 88);
3380                  else if (curChar == 40)
3381                     jjstateSet[jjnewStateCnt++] = 22;
3382                  break;
3383               case 0:
3384                  if (curChar == 58)
3385                     jjCheckNAddTwoStates(4, 5);
3386                  break;
3387               case 1:
3388                  if (curChar == 58)
3389                     jjCheckNAddTwoStates(2, 21);
3390                  break;
3391               case 2:
3392                  if ((0xfbffffffffffffffL & l) != 0L)
3393                     jjCheckNAddTwoStates(2, 21);
3394                  break;
3395               case 3:
3396                  if (curChar == 41)
3397                     jjCheckNAddStates(0, 3);
3398                  break;
3399               case 4:
3400                  if (curChar == 40)
3401                     jjstateSet[jjnewStateCnt++] = 1;
3402                  break;
3403               case 5:
3404                  if ((0x100002600L & l) != 0L)
3405                     jjCheckNAddStates(0, 3);
3406                  break;
3407               case 21:
3408                  if (curChar == 58)
3409                     jjstateSet[jjnewStateCnt++] = 3;
3410                  break;
3411               case 22:
3412                  if (curChar == 58)
3413                     jjstateSet[jjnewStateCnt++] = 0;
3414                  break;
3415               case 24:
3416                  if (curChar == 38)
3417                     jjAddStates(85, 88);
3418                  break;
3419               case 26:
3420                  if (curChar == 59 && kind > 238)
3421                     kind = 238;
3422                  break;
3423               case 38:
3424                  if (curChar == 35)
3425                     jjCheckNAddTwoStates(39, 41);
3426                  break;
3427               case 39:
3428                  if ((0x3ff000000000000L & l) != 0L)
3429                     jjCheckNAddTwoStates(39, 40);
3430                  break;
3431               case 40:
3432                  if (curChar == 59 && kind > 239)
3433                     kind = 239;
3434                  break;
3435               case 42:
3436                  if ((0x3ff000000000000L & l) != 0L)
3437                     jjCheckNAddTwoStates(42, 40);
3438                  break;
3439               case 43:
3440                  if (curChar == 38)
3441                     jjstateSet[jjnewStateCnt++] = 38;
3442                  break;
3443               case 44:
3444                  if ((0x100002600L & l) != 0L && kind > 240)
3445                     kind = 240;
3446                  break;
3447               case 45:
3448                  if ((0xefffffbfffffffffL & l) != 0L && kind > 241)
3449                     kind = 241;
3450                  break;
3451               default : break;
3452            }
3453         } while(i != startsAt);
3454      }
3455      else if (curChar < 128)
3456      {
3457         long l = 1L << (curChar & 077);
3458         MatchLoop: do
3459         {
3460            switch(jjstateSet[--i])
3461            {
3462               case 23:
3463                  if ((0xd7ffffffffffffffL & l) != 0L && kind > 241)
3464                     kind = 241;
3465                  break;
3466               case 2:
3467                  jjAddStates(4, 5);
3468                  break;
3469               case 6:
3470                  if (curChar == 97 && kind > 1)
3471                     kind = 1;
3472                  break;
3473               case 7:
3474                  if (curChar == 109)
3475                     jjstateSet[jjnewStateCnt++] = 6;
3476                  break;
3477               case 8:
3478                  if (curChar == 103)
3479                     jjstateSet[jjnewStateCnt++] = 7;
3480                  break;
3481               case 9:
3482                  if (curChar == 97)
3483                     jjstateSet[jjnewStateCnt++] = 8;
3484                  break;
3485               case 10:
3486                  if (curChar == 114)
3487                     jjstateSet[jjnewStateCnt++] = 9;
3488                  break;
3489               case 11:
3490                  if (curChar == 112)
3491                     jjstateSet[jjnewStateCnt++] = 10;
3492                  break;
3493               case 12:
3494                  if (curChar == 110 && kind > 1)
3495                     kind = 1;
3496                  break;
3497               case 13:
3498                  if (curChar == 111)
3499                     jjstateSet[jjnewStateCnt++] = 12;
3500                  break;
3501               case 14:
3502                  if (curChar == 105)
3503                     jjstateSet[jjnewStateCnt++] = 13;
3504                  break;
3505               case 15:
3506                  if (curChar == 115)
3507                     jjstateSet[jjnewStateCnt++] = 14;
3508                  break;
3509               case 16:
3510                  if (curChar == 110)
3511                     jjstateSet[jjnewStateCnt++] = 15;
3512                  break;
3513               case 17:
3514                  if (curChar == 101)
3515                     jjstateSet[jjnewStateCnt++] = 16;
3516                  break;
3517               case 18:
3518                  if (curChar == 116)
3519                     jjstateSet[jjnewStateCnt++] = 17;
3520                  break;
3521               case 19:
3522                  if (curChar == 120)
3523                     jjstateSet[jjnewStateCnt++] = 18;
3524                  break;
3525               case 20:
3526                  if (curChar == 101)
3527                     jjstateSet[jjnewStateCnt++] = 19;
3528                  break;
3529               case 25:
3530                  if (curChar == 116)
3531                     jjCheckNAdd(26);
3532                  break;
3533               case 27:
3534                  if (curChar == 108)
3535                     jjCheckNAdd(25);
3536                  break;
3537               case 28:
3538                  if (curChar == 103)
3539                     jjCheckNAdd(25);
3540                  break;
3541               case 29:
3542                  if (curChar == 111)
3543                     jjCheckNAdd(25);
3544                  break;
3545               case 30:
3546                  if (curChar == 117)
3547                     jjstateSet[jjnewStateCnt++] = 29;
3548                  break;
3549               case 31:
3550                  if (curChar == 113)
3551                     jjstateSet[jjnewStateCnt++] = 30;
3552                  break;
3553               case 32:
3554                  if (curChar == 97)
3555                     jjAddStates(89, 90);
3556                  break;
3557               case 33:
3558                  if (curChar == 112)
3559                     jjCheckNAdd(26);
3560                  break;
3561               case 34:
3562                  if (curChar == 109)
3563                     jjstateSet[jjnewStateCnt++] = 33;
3564                  break;
3565               case 35:
3566                  if (curChar == 115)
3567                     jjCheckNAdd(26);
3568                  break;
3569               case 36:
3570                  if (curChar == 111)
3571                     jjstateSet[jjnewStateCnt++] = 35;
3572                  break;
3573               case 37:
3574                  if (curChar == 112)
3575                     jjstateSet[jjnewStateCnt++] = 36;
3576                  break;
3577               case 41:
3578                  if (curChar == 120)
3579                     jjCheckNAdd(42);
3580                  break;
3581               case 42:
3582                  if ((0x7e0000007eL & l) != 0L)
3583                     jjCheckNAddTwoStates(42, 40);
3584                  break;
3585               default : break;
3586            }
3587         } while(i != startsAt);
3588      }
3589      else
3590      {
3591         int hiByte = (int)(curChar >> 8);
3592         int i1 = hiByte >> 6;
3593         long l1 = 1L << (hiByte & 077);
3594         int i2 = (curChar & 0xff) >> 6;
3595         long l2 = 1L << (curChar & 077);
3596         MatchLoop: do
3597         {
3598            switch(jjstateSet[--i])
3599            {
3600               case 23:
3601                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 241)
3602                     kind = 241;
3603                  break;
3604               case 2:
3605                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3606                     jjAddStates(4, 5);
3607                  break;
3608               default : break;
3609            }
3610         } while(i != startsAt);
3611      }
3612      if (kind != 0x7fffffff)
3613      {
3614         jjmatchedKind = kind;
3615         jjmatchedPos = curPos;
3616         kind = 0x7fffffff;
3617      }
3618      ++curPos;
3619      if ((i = jjnewStateCnt) == (startsAt = 46 - (jjnewStateCnt = startsAt)))
3620         return curPos;
3621      try { curChar = input_stream.readChar(); }
3622      catch(java.io.IOException JavaDoc e) { return curPos; }
3623   }
3624}
3625private final int jjStopStringLiteralDfa_19(int pos, long active0, long active1, long active2)
3626{
3627   switch (pos)
3628   {
3629      case 0:
3630         if ((active0 & 0x80000L) != 0L || (active2 & 0x200000L) != 0L)
3631            return 22;
3632         if ((active1 & 0x114410213000000L) != 0L || (active2 & 0x100000000L) != 0L)
3633         {
3634            jjmatchedKind = 173;
3635            return 546;
3636         }
3637         if ((active2 & 0xaL) != 0L)
3638         {
3639            jjmatchedKind = 173;
3640            return 438;
3641         }
3642         if ((active1 & 0x80000L) != 0L || (active2 & 0x80000010L) != 0L)
3643         {
3644            jjmatchedKind = 173;
3645            return 125;
3646         }
3647         if ((active1 & 0x3000000000000L) != 0L)
3648         {
3649            jjmatchedKind = 173;
3650            return 462;
3651         }
3652         if ((active1 & 0x1d00000000L) != 0L)
3653         {
3654            jjmatchedKind = 173;
3655            return 388;
3656         }
3657         if ((active1 & 0x2000000c000000L) != 0L)
3658         {
3659            jjmatchedKind = 173;
3660            return 69;
3661         }
3662         if ((active2 & 0x3000000000L) != 0L)
3663            return 547;
3664         if ((active1 & 0x28000L) != 0L || (active2 & 0x40000004L) != 0L)
3665         {
3666            jjmatchedKind = 173;
3667            return 24;
3668         }
3669         if ((active1 & 0x200000000000L) != 0L)
3670         {
3671            jjmatchedKind = 173;
3672            return 49;
3673         }
3674         if ((active1 & 0xc0800000000000L) != 0L)
3675         {
3676            jjmatchedKind = 173;
3677            return 344;
3678         }
3679         if ((active1 & 0x20000000000L) != 0L)
3680            return 96;
3681         if ((active1 & 0xd04000L) != 0L)
3682         {
3683            jjmatchedKind = 173;
3684            return 490;
3685         }
3686         if ((active2 & 0x10000000000L) != 0L)
3687            return 548;
3688         return -1;
3689      case 1:
3690         if ((active2 & 0x2L) != 0L)
3691         {
3692            if (jjmatchedPos != 1)
3693            {
3694               jjmatchedKind = 173;
3695               jjmatchedPos = 1;
3696            }
3697            return 437;
3698         }
3699         if ((active1 & 0x1b5c1030058c000L) != 0L || (active2 & 0x100000008L) != 0L)
3700         {
3701            if (jjmatchedPos != 1)
3702            {
3703               jjmatchedKind = 173;
3704               jjmatchedPos = 1;
3705            }
3706            return 546;
3707         }
3708         if ((active2 & 0x80000010L) != 0L)
3709         {
3710            if (jjmatchedPos != 1)
3711            {
3712               jjmatchedKind = 173;
3713               jjmatchedPos = 1;
3714            }
3715            return 124;
3716         }
3717         if ((active1 & 0xc00000000L) != 0L)
3718            return 387;
3719         if ((active0 & 0x80000L) != 0L)
3720            return 0;
3721         if ((active1 & 0x200101b800000L) != 0L || (active2 & 0x40000004L) != 0L)
3722            return 546;
3723         if ((active1 & 0x200000000000L) != 0L)
3724            return 48;
3725         if ((active1 & 0x20000L) != 0L)
3726            return 549;
3727         if ((active1 & 0x40000000000000L) != 0L)
3728         {
3729            if (jjmatchedPos != 1)
3730            {
3731               jjmatchedKind = 173;
3732               jjmatchedPos = 1;
3733            }
3734            return 343;
3735         }
3736         if ((active1 & 0x4000000L) != 0L)
3737            return 61;
3738         return -1;
3739      case 2:
3740         if ((active1 & 0x20010000088000L) != 0L)
3741            return 546;
3742         if ((active1 & 0x1d5c00700504000L) != 0L || (active2 & 0x1c0000018L) != 0L)
3743         {
3744            jjmatchedKind = 173;
3745            jjmatchedPos = 2;
3746            return 546;
3747         }
3748         if ((active2 & 0x2L) != 0L)
3749         {
3750            jjmatchedKind = 173;
3751            jjmatchedPos = 2;
3752            return 436;
3753         }
3754         return -1;
3755      case 3:
3756         if ((active1 & 0x81000100100000L) != 0L || (active2 & 0x2L) != 0L)
3757            return 546;
3758         if ((active1 & 0x154c00600404000L) != 0L || (active2 & 0x1c0000018L) != 0L)
3759         {
3760            jjmatchedKind = 173;
3761            jjmatchedPos = 3;
3762            return 546;
3763         }
3764         return -1;
3765      case 4:
3766         if ((active1 & 0x14000000000000L) != 0L)
3767            return 546;
3768         if ((active1 & 0x140c00600404000L) != 0L || (active2 & 0x1c0000018L) != 0L)
3769         {
3770            jjmatchedKind = 173;
3771            jjmatchedPos = 4;
3772            return 546;
3773         }
3774         return -1;
3775      case 5:
3776         if ((active1 & 0x40400200400000L) != 0L)
3777            return 546;
3778         if ((active1 & 0x100800400004000L) != 0L || (active2 & 0x1c0000018L) != 0L)
3779         {
3780            jjmatchedKind = 173;
3781            jjmatchedPos = 5;
3782            return 546;
3783         }
3784         return -1;
3785      case 6:
3786         if ((active2 & 0x10L) != 0L)
3787            return 546;
3788         if ((active1 & 0x100800400004000L) != 0L || (active2 & 0x1c0000008L) != 0L)
3789         {
3790            jjmatchedKind = 173;
3791            jjmatchedPos = 6;
3792            return 546;
3793         }
3794         return -1;
3795      case 7:
3796         if ((active1 & 0x100000000004000L) != 0L)
3797            return 546;
3798         if ((active1 & 0x800400000000L) != 0L || (active2 & 0x1c0000008L) != 0L)
3799         {
3800            jjmatchedKind = 173;
3801            jjmatchedPos = 7;
3802            return 546;
3803         }
3804         return -1;
3805      case 8:
3806         if ((active1 & 0x800400000000L) != 0L || (active2 & 0x40000008L) != 0L)
3807            return 546;
3808         if ((active2 & 0x180000000L) != 0L)
3809         {
3810            jjmatchedKind = 173;
3811            jjmatchedPos = 8;
3812            return 546;
3813         }
3814         return -1;
3815      case 9:
3816         if ((active2 & 0x80000000L) != 0L)
3817            return 546;
3818         if ((active2 & 0x100000000L) != 0L)
3819         {
3820            jjmatchedKind = 173;
3821            jjmatchedPos = 9;
3822            return 546;
3823         }
3824         return -1;
3825      default :
3826         return -1;
3827   }
3828}
3829private final int jjStartNfa_19(int pos, long active0, long active1, long active2)
3830{
3831   return jjMoveNfa_19(jjStopStringLiteralDfa_19(pos, active0, active1, active2), pos + 1);
3832}
3833private final int jjStartNfaWithStates_19(int pos, int kind, int state)
3834{
3835   jjmatchedKind = kind;
3836   jjmatchedPos = pos;
3837   try { curChar = input_stream.readChar(); }
3838   catch(java.io.IOException JavaDoc e) { return pos + 1; }
3839   return jjMoveNfa_19(state, pos + 1);
3840}
3841private final int jjMoveStringLiteralDfa0_19()
3842{
3843   switch(curChar)
3844   {
3845      case 33:
3846         return jjMoveStringLiteralDfa1_19(0x0L, 0x40000000000L, 0x0L);
3847      case 36:
3848         return jjStopAtPos(0, 135);
3849      case 40:
3850         jjmatchedKind = 149;
3851         return jjMoveStringLiteralDfa1_19(0x80000L, 0x0L, 0x0L);
3852      case 41:
3853         return jjStartNfaWithStates_19(0, 168, 548);
3854      case 42:
3855         return jjStartNfaWithStates_19(0, 105, 96);
3856      case 43:
3857         return jjStopAtPos(0, 151);
3858      case 44:
3859         return jjStopAtPos(0, 155);
3860      case 45:
3861         return jjStopAtPos(0, 150);
3862      case 46:
3863         jjmatchedKind = 165;
3864         return jjMoveStringLiteralDfa1_19(0x0L, 0x0L, 0x1000000000L);
3865      case 47:
3866         jjmatchedKind = 154;
3867         return jjMoveStringLiteralDfa1_19(0x0L, 0x0L, 0x2000000L);
3868      case 58:
3869         return jjMoveStringLiteralDfa1_19(0x0L, 0x40000L, 0x0L);
3870      case 59:
3871         return jjStopAtPos(0, 152);
3872      case 60:
3873         jjmatchedKind = 103;
3874         return jjMoveStringLiteralDfa1_19(0x0L, 0x6000000000L, 0x0L);
3875      case 61:
3876         return jjStopAtPos(0, 85);
3877      case 62:
3878         jjmatchedKind = 95;
3879         return jjMoveStringLiteralDfa1_19(0x0L, 0x60000000L, 0x0L);
3880      case 63:
3881         return jjStopAtPos(0, 133);
3882      case 91:
3883         return jjStopAtPos(0, 148);
3884      case 93:
3885         return jjStopAtPos(0, 169);
3886      case 97:
3887         return jjMoveStringLiteralDfa1_19(0x0L, 0x28000L, 0x40000004L);
3888      case 99:
3889         return jjMoveStringLiteralDfa1_19(0x0L, 0x0L, 0xaL);
3890      case 100:
3891         return jjMoveStringLiteralDfa1_19(0x0L, 0x80000L, 0x80000010L);
3892      case 101:
3893         return jjMoveStringLiteralDfa1_19(0x0L, 0xd04000L, 0x0L);
3894      case 103:
3895         return jjMoveStringLiteralDfa1_19(0x0L, 0x203000000L, 0x0L);
3896      case 105:
3897         return jjMoveStringLiteralDfa1_19(0x0L, 0x1d00000000L, 0x0L);
3898      case 108:
3899         return jjMoveStringLiteralDfa1_19(0x0L, 0x2000000c000000L, 0x0L);
3900      case 109:
3901         return jjMoveStringLiteralDfa1_19(0x0L, 0x10000000000L, 0x0L);
3902      case 110:
3903         return jjMoveStringLiteralDfa1_19(0x0L, 0x10000000L, 0x0L);
3904      case 111:
3905         return jjMoveStringLiteralDfa1_19(0x0L, 0x200000000000L, 0x0L);
3906      case 112:
3907         return jjMoveStringLiteralDfa1_19(0x0L, 0x100000000000000L, 0x100000000L);
3908      case 114:
3909         return jjMoveStringLiteralDfa1_19(0x0L, 0x400000000000L, 0x0L);
3910      case 115:
3911         return jjMoveStringLiteralDfa1_19(0x0L, 0xc0800000000000L, 0x0L);
3912      case 116:
3913         return jjMoveStringLiteralDfa1_19(0x0L, 0x3000000000000L, 0x0L);
3914      case 117:
3915         return jjMoveStringLiteralDfa1_19(0x0L, 0x4000000000000L, 0x0L);
3916      case 119:
3917         return jjMoveStringLiteralDfa1_19(0x0L, 0x10000000000000L, 0x0L);
3918      case 123:
3919         jjmatchedKind = 156;
3920         return jjMoveStringLiteralDfa1_19(0x100000L, 0x0L, 0x0L);
3921      case 124:
3922         return jjStopAtPos(0, 115);
3923      case 125:
3924         return jjStopAtPos(0, 157);
3925      default :
3926         return jjMoveNfa_19(23, 0);
3927   }
3928}
3929private final int jjMoveStringLiteralDfa1_19(long active0, long active1, long active2)
3930{
3931   try { curChar = input_stream.readChar(); }
3932   catch(java.io.IOException JavaDoc e) {
3933      jjStopStringLiteralDfa_19(0, active0, active1, active2);
3934      return 1;
3935   }
3936   switch(curChar)
3937   {
3938      case 45:
3939         return jjMoveStringLiteralDfa2_19(active0, 0x100000L, active1, 0L, active2, 0L);
3940      case 46:
3941         if ((active2 & 0x1000000000L) != 0L)
3942            return jjStopAtPos(1, 164);
3943         break;
3944      case 47:
3945         if ((active2 & 0x2000000L) != 0L)
3946            return jjStopAtPos(1, 153);
3947         break;
3948      case 58:
3949         if ((active0 & 0x80000L) != 0L)
3950            return jjStartNfaWithStates_19(1, 19, 0);
3951         break;
3952      case 60:
3953         if ((active1 & 0x4000000000L) != 0L)
3954            return jjStopAtPos(1, 102);
3955         break;
3956      case 61:
3957         if ((active1 & 0x40000L) != 0L)
3958            return jjStopAtPos(1, 82);
3959         else if ((active1 & 0x20000000L) != 0L)
3960            return jjStopAtPos(1, 93);
3961         else if ((active1 & 0x2000000000L) != 0L)
3962            return jjStopAtPos(1, 101);
3963         else if ((active1 & 0x40000000000L) != 0L)
3964            return jjStopAtPos(1, 106);
3965         break;
3966      case 62:
3967         if ((active1 & 0x40000000L) != 0L)
3968            return jjStopAtPos(1, 94);
3969         break;
3970      case 97:
3971         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x20800000000000L, active2, 0x2L);
3972      case 100:
3973         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x100000000L, active2, 0L);
3974      case 101:
3975         if ((active1 & 0x1000000L) != 0L)
3976            return jjStartNfaWithStates_19(1, 88, 546);
3977         else if ((active1 & 0x4000000L) != 0L)
3978            return jjStartNfaWithStates_19(1, 90, 61);
3979         else if ((active1 & 0x10000000L) != 0L)
3980            return jjStartNfaWithStates_19(1, 92, 546);
3981         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x400000000000L, active2, 0x80000010L);
3982      case 104:
3983         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x11000000000000L, active2, 0L);
3984      case 105:
3985         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x80000L, active2, 0L);
3986      case 107:
3987         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x80000000000000L, active2, 0L);
3988      case 108:
3989         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x200100000L, active2, 0x100000000L);
3990      case 110:
3991         if ((active1 & 0x800000000L) != 0L)
3992         {
3993            jjmatchedKind = 99;
3994            jjmatchedPos = 1;
3995         }
3996         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x4000400008000L, active2, 0L);
3997      case 111:
3998         if ((active1 & 0x2000000000000L) != 0L)
3999            return jjStartNfaWithStates_19(1, 113, 546);
4000         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x10000000000L, active2, 0x8L);
4001      case 113:
4002         if ((active1 & 0x800000L) != 0L)
4003            return jjStartNfaWithStates_19(1, 87, 546);
4004         break;
4005      case 114:
4006         if ((active1 & 0x200000000000L) != 0L)
4007            return jjStartNfaWithStates_19(1, 109, 48);
4008         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x100000000000000L, active2, 0L);
4009      case 115:
4010         if ((active1 & 0x1000000000L) != 0L)
4011            return jjStartNfaWithStates_19(1, 100, 546);
4012         else if ((active2 & 0x4L) != 0L)
4013         {
4014            jjmatchedKind = 130;
4015            jjmatchedPos = 1;
4016         }
4017         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0L, active2, 0x40000000L);
4018      case 116:
4019         if ((active1 & 0x20000L) != 0L)
4020            return jjStartNfaWithStates_19(1, 81, 549);
4021         else if ((active1 & 0x2000000L) != 0L)
4022            return jjStartNfaWithStates_19(1, 89, 546);
4023         else if ((active1 & 0x8000000L) != 0L)
4024            return jjStartNfaWithStates_19(1, 91, 546);
4025         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x40000000000000L, active2, 0L);
4026      case 120:
4027         return jjMoveStringLiteralDfa2_19(active0, 0L, active1, 0x404000L, active2, 0L);
4028      default :
4029         break;
4030   }
4031   return jjStartNfa_19(0, active0, active1, active2);
4032}
4033private final int jjMoveStringLiteralDfa2_19(long old0, long active0, long old1, long active1, long old2, long active2)
4034{
4035   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
4036      return jjStartNfa_19(0, old0, old1, old2);
4037   try { curChar = input_stream.readChar(); }
4038   catch(java.io.IOException JavaDoc e) {
4039      jjStopStringLiteralDfa_19(1, active0, active1, active2);
4040      return 2;
4041   }
4042   switch(curChar)
4043   {
4044      case 45:
4045         if ((active0 & 0x100000L) != 0L)
4046            return jjStopAtPos(2, 20);
4047         break;
4048      case 97:
4049         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0L, active2, 0x100000000L);
4050      case 99:
4051         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0x400000L, active2, 0x40000000L);
4052      case 100:
4053         if ((active1 & 0x8000L) != 0L)
4054            return jjStartNfaWithStates_19(2, 79, 546);
4055         else if ((active1 & 0x10000000000L) != 0L)
4056            return jjStartNfaWithStates_19(2, 104, 546);
4057         break;
4058      case 101:
4059         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0x111000000000000L, active2, 0L);
4060      case 102:
4061         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0L, active2, 0x10L);
4062      case 105:
4063         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0x84000100000000L, active2, 0L);
4064      case 108:
4065         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0L, active2, 0x8L);
4066      case 111:
4067         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0x200000000L, active2, 0L);
4068      case 114:
4069         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0x40000000000000L, active2, 0L);
4070      case 115:
4071         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0x100000L, active2, 0x80000002L);
4072      case 116:
4073         return jjMoveStringLiteralDfa3_19(active0, 0L, active1, 0xc00400004000L, active2, 0L);
4074      case 118:
4075         if ((active1 & 0x80000L) != 0L)
4076            return jjStartNfaWithStates_19(2, 83, 546);
4077         break;
4078      case 120:
4079         if ((active1 & 0x20000000000000L) != 0L)
4080            return jjStartNfaWithStates_19(2, 117, 546);
4081         break;
4082      default :
4083         break;
4084   }
4085   return jjStartNfa_19(1, active0, active1, active2);
4086}
4087private final int jjMoveStringLiteralDfa3_19(long old0, long active0, long old1, long active1, long old2, long active2)
4088{
4089   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
4090      return jjStartNfa_19(1, old0, old1, old2);
4091   try { curChar = input_stream.readChar(); }
4092   catch(java.io.IOException JavaDoc e) {
4093      jjStopStringLiteralDfa_19(2, 0L, active1, active2);
4094      return 3;
4095   }
4096   switch(curChar)
4097   {
4098      case 97:
4099         return jjMoveStringLiteralDfa4_19(active1, 0L, active2, 0x10L);
4100      case 98:
4101         return jjMoveStringLiteralDfa4_19(active1, 0x200000000L, active2, 0L);
4102      case 99:
4103         return jjMoveStringLiteralDfa4_19(active1, 0L, active2, 0x180000000L);
4104      case 101:
4105         if ((active1 & 0x100000L) != 0L)
4106            return jjStartNfaWithStates_19(3, 84, 546);
4107         else if ((active2 & 0x2L) != 0L)
4108            return jjStartNfaWithStates_19(3, 129, 546);
4109         return jjMoveStringLiteralDfa4_19(active1, 0x400404000L, active2, 0x40000000L);
4110      case 105:
4111         return jjMoveStringLiteralDfa4_19(active1, 0x40800000000000L, active2, 0L);
4112      case 108:
4113         return jjMoveStringLiteralDfa4_19(active1, 0L, active2, 0x8L);
4114      case 110:
4115         if ((active1 & 0x1000000000000L) != 0L)
4116            return jjStartNfaWithStates_19(3, 112, 546);
4117         break;
4118      case 111:
4119         return jjMoveStringLiteralDfa4_19(active1, 0x4000000000000L, active2, 0L);
4120      case 112:
4121         if ((active1 & 0x80000000000000L) != 0L)
4122            return jjStartNfaWithStates_19(3, 119, 546);
4123         break;
4124      case 114:
4125         return jjMoveStringLiteralDfa4_19(active1, 0x10000000000000L, active2, 0L);
4126      case 115:
4127         return jjMoveStringLiteralDfa4_19(active1, 0x100000000000000L, active2, 0L);
4128      case 117:
4129         return jjMoveStringLiteralDfa4_19(active1, 0x400000000000L, active2, 0L);
4130      case 118:
4131         if ((active1 & 0x100000000L) != 0L)
4132            return jjStartNfaWithStates_19(3, 96, 546);
4133         break;
4134      default :
4135         break;
4136   }
4137   return jjStartNfa_19(2, 0L, active1, active2);
4138}
4139private final int jjMoveStringLiteralDfa4_19(long old1, long active1, long old2, long active2)
4140{
4141   if (((active1 &= old1) | (active2 &= old2)) == 0L)
4142      return jjStartNfa_19(2, 0L, old1, old2);
4143   try { curChar = input_stream.readChar(); }
4144   catch(java.io.IOException JavaDoc e) {
4145      jjStopStringLiteralDfa_19(3, 0L, active1, active2);
4146      return 4;
4147   }
4148   switch(curChar)
4149   {
4150      case 97:
4151         return jjMoveStringLiteralDfa5_19(active1, 0x200000000L, active2, 0x8L);
4152      case 99:
4153         return jjMoveStringLiteralDfa5_19(active1, 0x40000000000000L, active2, 0L);
4154      case 101:
4155         if ((active1 & 0x10000000000000L) != 0L)
4156            return jjStartNfaWithStates_19(4, 116, 546);
4157         return jjMoveStringLiteralDfa5_19(active1, 0x100000000000000L, active2, 0x180000000L);
4158      case 110:
4159         if ((active1 & 0x4000000000000L) != 0L)
4160            return jjStartNfaWithStates_19(4, 114, 546);
4161         return jjMoveStringLiteralDfa5_19(active1, 0L, active2, 0x40000000L);
4162      case 112:
4163         return jjMoveStringLiteralDfa5_19(active1, 0x400000L, active2, 0L);
4164      case 114:
4165         return jjMoveStringLiteralDfa5_19(active1, 0x400400004000L, active2, 0L);
4166      case 115:
4167         return jjMoveStringLiteralDfa5_19(active1, 0x800000000000L, active2, 0L);
4168      case 117:
4169         return jjMoveStringLiteralDfa5_19(active1, 0L, active2, 0x10L);
4170      default :
4171         break;
4172   }
4173   return jjStartNfa_19(3, 0L, active1, active2);
4174}
4175private final int jjMoveStringLiteralDfa5_19(long old1, long active1, long old2, long active2)
4176{
4177   if (((active1 &= old1) | (active2 &= old2)) == 0L)
4178      return jjStartNfa_19(3, 0L, old1, old2);
4179   try { curChar = input_stream.readChar(); }
4180   catch(java.io.IOException JavaDoc e) {
4181      jjStopStringLiteralDfa_19(4, 0L, active1, active2);
4182      return 5;
4183   }
4184   switch(curChar)
4185   {
4186      case 95:
4187         return jjMoveStringLiteralDfa6_19(active1, 0L, active2, 0x100000000L);
4188      case 100:
4189         return jjMoveStringLiteralDfa6_19(active1, 0L, active2, 0x40000000L);
4190      case 102:
4191         return jjMoveStringLiteralDfa6_19(active1, 0x800000000000L, active2, 0L);
4192      case 108:
4193         if ((active1 & 0x200000000L) != 0L)
4194            return jjStartNfaWithStates_19(5, 97, 546);
4195         return jjMoveStringLiteralDfa6_19(active1, 0L, active2, 0x10L);
4196      case 110:
4197         if ((active1 & 0x400000000000L) != 0L)
4198            return jjStartNfaWithStates_19(5, 110, 546);
4199         return jjMoveStringLiteralDfa6_19(active1, 0x4000L, active2, 0x80000000L);
4200      case 114:
4201         return jjMoveStringLiteralDfa6_19(active1, 0x100000000000000L, active2, 0L);
4202      case 115:
4203         return jjMoveStringLiteralDfa6_19(active1, 0x400000000L, active2, 0L);
4204      case 116:
4205         if ((active1 & 0x400000L) != 0L)
4206            return jjStartNfaWithStates_19(5, 86, 546);
4207         else if ((active1 & 0x40000000000000L) != 0L)
4208            return jjStartNfaWithStates_19(5, 118, 546);
4209         return jjMoveStringLiteralDfa6_19(active1, 0L, active2, 0x8L);
4210      default :
4211         break;
4212   }
4213   return jjStartNfa_19(4, 0L, active1, active2);
4214}
4215private final int jjMoveStringLiteralDfa6_19(long old1, long active1, long old2, long active2)
4216{
4217   if (((active1 &= old1) | (active2 &= old2)) == 0L)
4218      return jjStartNfa_19(4, 0L, old1, old2);
4219   try { curChar = input_stream.readChar(); }
4220   catch(java.io.IOException JavaDoc e) {
4221      jjStopStringLiteralDfa_19(5, 0L, active1, active2);
4222      return 6;
4223   }
4224   switch(curChar)
4225   {
4226      case 97:
4227         return jjMoveStringLiteralDfa7_19(active1, 0x4000L, active2, 0L);
4228      case 100:
4229         return jjMoveStringLiteralDfa7_19(active1, 0L, active2, 0x80000000L);
4230      case 101:
4231         return jjMoveStringLiteralDfa7_19(active1, 0x400000000L, active2, 0L);
4232      case 105:
4233         return jjMoveStringLiteralDfa7_19(active1, 0x800000000000L, active2, 0x40000008L);
4234      case 111:
4235         return jjMoveStringLiteralDfa7_19(active1, 0L, active2, 0x100000000L);
4236      case 116:
4237         if ((active2 & 0x10L) != 0L)
4238            return jjStartNfaWithStates_19(6, 132, 546);
4239         break;
4240      case 118:
4241         return jjMoveStringLiteralDfa7_19(active1, 0x100000000000000L, active2, 0L);
4242      default :
4243         break;
4244   }
4245   return jjStartNfa_19(5, 0L, active1, active2);
4246}
4247private final int jjMoveStringLiteralDfa7_19(long old1, long active1, long old2, long active2)
4248{
4249   if (((active1 &= old1) | (active2 &= old2)) == 0L)
4250      return jjStartNfa_19(5, 0L, old1, old2);
4251   try { curChar = input_stream.readChar(); }
4252   catch(java.io.IOException JavaDoc e) {
4253      jjStopStringLiteralDfa_19(6, 0L, active1, active2);
4254      return 7;
4255   }
4256   switch(curChar)
4257   {
4258      case 99:
4259         return jjMoveStringLiteralDfa8_19(active1, 0x400000000L, active2, 0L);
4260      case 101:
4261         if ((active1 & 0x100000000000000L) != 0L)
4262            return jjStartNfaWithStates_19(7, 120, 546);
4263         return jjMoveStringLiteralDfa8_19(active1, 0x800000000000L, active2, 0L);
4264      case 105:
4265         return jjMoveStringLiteralDfa8_19(active1, 0L, active2, 0x80000000L);
4266      case 108:
4267         if ((active1 & 0x4000L) != 0L)
4268            return jjStartNfaWithStates_19(7, 78, 546);
4269         break;
4270      case 110:
4271         return jjMoveStringLiteralDfa8_19(active1, 0L, active2, 0x40000000L);
4272      case 111:
4273         return jjMoveStringLiteralDfa8_19(active1, 0L, active2, 0x8L);
4274      case 114:
4275         return jjMoveStringLiteralDfa8_19(active1, 0L, active2, 0x100000000L);
4276      default :
4277         break;
4278   }
4279   return jjStartNfa_19(6, 0L, active1, active2);
4280}
4281private final int jjMoveStringLiteralDfa8_19(long old1, long active1, long old2, long active2)
4282{
4283   if (((active1 &= old1) | (active2 &= old2)) == 0L)
4284      return jjStartNfa_19(6, 0L, old1, old2);
4285   try { curChar = input_stream.readChar(); }
4286   catch(java.io.IOException JavaDoc e) {
4287      jjStopStringLiteralDfa_19(7, 0L, active1, active2);
4288      return 8;
4289   }
4290   switch(curChar)
4291   {
4292      case 100:
4293         return jjMoveStringLiteralDfa9_19(active1, 0L, active2, 0x100000000L);
4294      case 103:
4295         if ((active2 & 0x40000000L) != 0L)
4296            return jjStartNfaWithStates_19(8, 158, 546);
4297         break;
4298      case 110:
4299         if ((active2 & 0x8L) != 0L)
4300            return jjStartNfaWithStates_19(8, 131, 546);
4301         return jjMoveStringLiteralDfa9_19(active1, 0L, active2, 0x80000000L);
4302      case 115:
4303         if ((active1 & 0x800000000000L) != 0L)
4304            return jjStartNfaWithStates_19(8, 111, 546);
4305         break;
4306      case 116:
4307         if ((active1 & 0x400000000L) != 0L)
4308            return jjStartNfaWithStates_19(8, 98, 546);
4309         break;
4310      default :
4311         break;
4312   }
4313   return jjStartNfa_19(7, 0L, active1, active2);
4314}
4315private final int jjMoveStringLiteralDfa9_19(long old1, long active1, long old2, long active2)
4316{
4317   if (((active1 &= old1) | (active2 &= old2)) == 0L)
4318      return jjStartNfa_19(7, 0L, old1, old2);
4319   try { curChar = input_stream.readChar(); }
4320   catch(java.io.IOException JavaDoc e) {
4321      jjStopStringLiteralDfa_19(8, 0L, 0L, active2);
4322      return 9;
4323   }
4324   switch(curChar)
4325   {
4326      case 101:
4327         return jjMoveStringLiteralDfa10_19(active2, 0x100000000L);
4328      case 103:
4329         if ((active2 & 0x80000000L) != 0L)
4330            return jjStartNfaWithStates_19(9, 159, 546);
4331         break;
4332      default :
4333         break;
4334   }
4335   return jjStartNfa_19(8, 0L, 0L, active2);
4336}
4337private final int jjMoveStringLiteralDfa10_19(long old2, long active2)
4338{
4339   if (((active2 &= old2)) == 0L)
4340      return jjStartNfa_19(8, 0L, 0L, old2);
4341   try { curChar = input_stream.readChar(); }
4342   catch(java.io.IOException JavaDoc e) {
4343      jjStopStringLiteralDfa_19(9, 0L, 0L, active2);
4344      return 10;
4345   }
4346   switch(curChar)
4347   {
4348      case 114:
4349         if ((active2 & 0x100000000L) != 0L)
4350            return jjStartNfaWithStates_19(10, 160, 546);
4351         break;
4352      default :
4353         break;
4354   }
4355   return jjStartNfa_19(9, 0L, 0L, active2);
4356}
4357private final int jjMoveNfa_19(int startState, int curPos)
4358{
4359   int[] nextStates;
4360   int startsAt = 0;
4361   jjnewStateCnt = 546;
4362   int i = 1;
4363   jjstateSet[0] = startState;
4364   int j, kind = 0x7fffffff;
4365   for (;;)
4366   {
4367      if (++jjround == 0x7fffffff)
4368         ReInitRounds();
4369      if (curChar < 64)
4370      {
4371         long l = 1L << curChar;
4372         MatchLoop: do
4373         {
4374            switch(jjstateSet[--i])
4375            {
4376               case 547:
4377                  if ((0x3ff000000000000L & l) != 0L)
4378                     jjCheckNAddTwoStates(526, 527);
4379                  if ((0x3ff000000000000L & l) != 0L)
4380                  {
4381                     if (kind > 163)
4382                        kind = 163;
4383                     jjCheckNAdd(525);
4384                  }
4385                  break;
4386               case 462:
4387                  if ((0x3ff600000000000L & l) != 0L)
4388                  {
4389                     if (kind > 173)
4390                        kind = 173;
4391                     jjCheckNAdd(545);
4392                  }
4393                  else if (curChar == 58)
4394                     jjstateSet[jjnewStateCnt++] = 544;
4395                  if ((0x3ff600000000000L & l) != 0L)
4396                     jjCheckNAddTwoStates(542, 543);
4397                  else if (curChar == 58)
4398                     jjstateSet[jjnewStateCnt++] = 541;
4399                  if ((0x3ff600000000000L & l) != 0L)
4400                     jjCheckNAddTwoStates(539, 540);
4401                  break;
4402               case 437:
4403                  if ((0x3ff600000000000L & l) != 0L)
4404                  {
4405                     if (kind > 173)
4406                        kind = 173;
4407                     jjCheckNAdd(545);
4408                  }
4409                  else if (curChar == 58)
4410                     jjstateSet[jjnewStateCnt++] = 544;
4411                  if ((0x3ff600000000000L & l) != 0L)
4412                     jjCheckNAddTwoStates(542, 543);
4413                  else if (curChar == 58)
4414                     jjstateSet[jjnewStateCnt++] = 541;
4415                  if ((0x3ff600000000000L & l) != 0L)
4416                     jjCheckNAddTwoStates(539, 540);
4417                  break;
4418               case 61:
4419                  if ((0x3ff600000000000L & l) != 0L)
4420                  {
4421                     if (kind > 173)
4422                        kind = 173;
4423                     jjCheckNAdd(545);
4424                  }
4425                  else if (curChar == 58)
4426                     jjstateSet[jjnewStateCnt++] = 544;
4427                  if ((0x3ff600000000000L & l) != 0L)
4428                     jjCheckNAddTwoStates(542, 543);
4429                  else if (curChar == 58)
4430                     jjstateSet[jjnewStateCnt++] = 541;
4431                  if ((0x3ff600000000000L & l) != 0L)
4432                     jjCheckNAddTwoStates(539, 540);
4433                  break;
4434               case 344:
4435                  if ((0x3ff600000000000L & l) != 0L)
4436                  {
4437                     if (kind > 173)
4438                        kind = 173;
4439                     jjCheckNAdd(545);
4440                  }
4441                  else if (curChar == 58)
4442                     jjstateSet[jjnewStateCnt++] = 544;
4443                  if ((0x3ff600000000000L & l) != 0L)
4444                     jjCheckNAddTwoStates(542, 543);
4445                  else if (curChar == 58)
4446                     jjstateSet[jjnewStateCnt++] = 541;
4447                  if ((0x3ff600000000000L & l) != 0L)
4448                     jjCheckNAddTwoStates(539, 540);
4449                  break;
4450               case 343:
4451                  if ((0x3ff600000000000L & l) != 0L)
4452                  {
4453                     if (kind > 173)
4454                        kind = 173;
4455                     jjCheckNAdd(545);
4456                  }
4457                  else if (curChar == 58)
4458                     jjstateSet[jjnewStateCnt++] = 544;
4459                  if ((0x3ff600000000000L & l) != 0L)
4460                     jjCheckNAddTwoStates(542, 543);
4461                  else if (curChar == 58)
4462                     jjstateSet[jjnewStateCnt++] = 541;
4463                  if ((0x3ff600000000000L & l) != 0L)
4464                     jjCheckNAddTwoStates(539, 540);
4465                  break;
4466               case 387:
4467                  if ((0x3ff600000000000L & l) != 0L)
4468                  {
4469                     if (kind > 173)
4470                        kind = 173;
4471                     jjCheckNAdd(545);
4472                  }
4473                  else if (curChar == 58)
4474                     jjstateSet[jjnewStateCnt++] = 544;
4475                  if ((0x3ff600000000000L & l) != 0L)
4476                     jjCheckNAddTwoStates(542, 543);
4477                  else if (curChar == 58)
4478                     jjstateSet[jjnewStateCnt++] = 541;
4479                  if ((0x3ff600000000000L & l) != 0L)
4480                     jjCheckNAddTwoStates(539, 540);
4481                  break;
4482               case 23:
4483                  if ((0x3ff000000000000L & l) != 0L)
4484                  {
4485                     if (kind > 167)
4486                        kind = 167;
4487                     jjCheckNAddStates(91, 96);
4488                  }
4489                  else if (curChar == 46)
4490                     jjCheckNAddTwoStates(525, 526);
4491                  else if (curChar == 39)
4492                     jjCheckNAddTwoStates(103, 104);
4493                  else if (curChar == 34)
4494                     jjCheckNAddTwoStates(100, 101);
4495                  else if (curChar == 42)
4496                     jjstateSet[jjnewStateCnt++] = 96;
4497                  else if (curChar == 41)
4498                     jjCheckNAddTwoStates(75, 76);
4499                  else if (curChar == 40)
4500                     jjstateSet[jjnewStateCnt++] = 22;
4501                  break;
4502               case 125:
4503                  if ((0x3ff600000000000L & l) != 0L)
4504                  {
4505                     if (kind > 173)
4506                        kind = 173;
4507                     jjCheckNAdd(545);
4508                  }
4509                  else if (curChar == 58)
4510                     jjstateSet[jjnewStateCnt++] = 544;
4511                  if ((0x3ff600000000000L & l) != 0L)
4512                     jjCheckNAddTwoStates(542, 543);
4513                  else if (curChar == 58)
4514                     jjstateSet[jjnewStateCnt++] = 541;
4515                  if ((0x3ff600000000000L & l) != 0L)
4516                     jjCheckNAddTwoStates(539, 540);
4517                  break;
4518               case 438:
4519                  if ((0x3ff600000000000L & l) != 0L)
4520                  {
4521                     if (kind > 173)
4522                        kind = 173;
4523                     jjCheckNAdd(545);
4524                  }
4525                  else if (curChar == 58)
4526                     jjstateSet[jjnewStateCnt++] = 544;
4527                  if ((0x3ff600000000000L & l) != 0L)
4528                     jjCheckNAddTwoStates(542, 543);
4529                  else if (curChar == 58)
4530                     jjstateSet[jjnewStateCnt++] = 541;
4531                  if ((0x3ff600000000000L & l) != 0L)
4532                     jjCheckNAddTwoStates(539, 540);
4533                  break;
4534               case 436:
4535                  if ((0x3ff600000000000L & l) != 0L)
4536                  {
4537                     if (kind > 173)
4538                        kind = 173;
4539                     jjCheckNAdd(545);
4540                  }
4541                  else if (curChar == 58)
4542                     jjstateSet[jjnewStateCnt++] = 544;
4543                  if ((0x3ff600000000000L & l) != 0L)
4544                     jjCheckNAddTwoStates(542, 543);
4545                  else if (curChar == 58)
4546                     jjstateSet[jjnewStateCnt++] = 541;
4547                  if ((0x3ff600000000000L & l) != 0L)
4548                     jjCheckNAddTwoStates(539, 540);
4549                  break;
4550               case 48:
4551                  if ((0x3ff600000000000L & l) != 0L)
4552                  {
4553                     if (kind > 173)
4554                        kind = 173;
4555                     jjCheckNAdd(545);
4556                  }
4557                  else if (curChar == 58)
4558                     jjstateSet[jjnewStateCnt++] = 544;
4559                  if ((0x3ff600000000000L & l) != 0L)
4560                     jjCheckNAddTwoStates(542, 543);
4561                  else if (curChar == 58)
4562                     jjstateSet[jjnewStateCnt++] = 541;
4563                  if ((0x3ff600000000000L & l) != 0L)
4564                     jjCheckNAddTwoStates(539, 540);
4565                  break;
4566               case 24:
4567                  if ((0x3ff600000000000L & l) != 0L)
4568                  {
4569                     if (kind > 173)
4570                        kind = 173;
4571                     jjCheckNAdd(545);
4572                  }
4573                  else if (curChar == 58)
4574                     jjstateSet[jjnewStateCnt++] = 544;
4575                  if ((0x3ff600000000000L & l) != 0L)
4576                     jjCheckNAddTwoStates(542, 543);
4577                  else if (curChar == 58)
4578                     jjstateSet[jjnewStateCnt++] = 541;
4579                  if ((0x3ff600000000000L & l) != 0L)
4580                     jjCheckNAddTwoStates(539, 540);
4581                  break;
4582               case 546:
4583                  if ((0x3ff600000000000L & l) != 0L)
4584                  {
4585                     if (kind > 173)
4586                        kind = 173;
4587                     jjCheckNAdd(545);
4588                  }
4589                  else if (curChar == 58)
4590                     jjstateSet[jjnewStateCnt++] = 544;
4591                  if ((0x3ff600000000000L & l) != 0L)
4592                     jjCheckNAddTwoStates(542, 543);
4593                  else if (curChar == 58)
4594                     jjstateSet[jjnewStateCnt++] = 541;
4595                  if ((0x3ff600000000000L & l) != 0L)
4596                     jjCheckNAddTwoStates(539, 540);
4597                  break;
4598               case 548:
4599                  if ((0x100002600L & l) != 0L)
4600                     jjCheckNAddStates(97, 99);
4601                  else if (curChar == 40)
4602                     jjstateSet[jjnewStateCnt++] = 72;
4603                  break;
4604               case 49:
4605                  if ((0x3ff600000000000L & l) != 0L)
4606                  {
4607                     if (kind > 173)
4608                        kind = 173;
4609                     jjCheckNAdd(545);
4610                  }
4611                  else if (curChar == 58)
4612                     jjstateSet[jjnewStateCnt++] = 544;
4613                  if ((0x3ff600000000000L & l) != 0L)
4614                     jjCheckNAddTwoStates(542, 543);
4615                  else if (curChar == 58)
4616                     jjstateSet[jjnewStateCnt++] = 541;
4617                  if ((0x3ff600000000000L & l) != 0L)
4618                     jjCheckNAddTwoStates(539, 540);
4619                  break;
4620               case 124:
4621                  if ((0x3ff600000000000L & l) != 0L)
4622                  {
4623                     if (kind > 173)
4624                        kind = 173;
4625                     jjCheckNAdd(545);
4626                  }
4627                  else if (curChar == 58)
4628                     jjstateSet[jjnewStateCnt++] = 544;
4629                  if ((0x3ff600000000000L & l) != 0L)
4630                     jjCheckNAddTwoStates(542, 543);
4631                  else if (curChar == 58)
4632                     jjstateSet[jjnewStateCnt++] = 541;
4633                  if ((0x3ff600000000000L & l) != 0L)
4634                     jjCheckNAddTwoStates(539, 540);
4635                  break;
4636               case 388:
4637                  if ((0x3ff600000000000L & l) != 0L)
4638                  {
4639                     if (kind > 173)
4640                        kind = 173;
4641                     jjCheckNAdd(545);
4642                  }
4643                  else if (curChar == 58)
4644                     jjstateSet[jjnewStateCnt++] = 544;
4645                  if ((0x3ff600000000000L & l) != 0L)
4646                     jjCheckNAddTwoStates(542, 543);
4647                  else if (curChar == 58)
4648                     jjstateSet[jjnewStateCnt++] = 541;
4649                  if ((0x3ff600000000000L & l) != 0L)
4650                     jjCheckNAddTwoStates(539, 540);
4651                  break;
4652               case 69:
4653                  if ((0x3ff600000000000L & l) != 0L)
4654                  {
4655                     if (kind > 173)
4656                        kind = 173;
4657                     jjCheckNAdd(545);
4658                  }
4659                  else if (curChar == 58)
4660                     jjstateSet[jjnewStateCnt++] = 544;
4661                  if ((0x3ff600000000000L & l) != 0L)
4662                     jjCheckNAddTwoStates(542, 543);
4663                  else if (curChar == 58)
4664                     jjstateSet[jjnewStateCnt++] = 541;
4665                  if ((0x3ff600000000000L & l) != 0L)
4666                     jjCheckNAddTwoStates(539, 540);
4667                  break;
4668               case 549:
4669                  if ((0x3ff600000000000L & l) != 0L)
4670                  {
4671                     if (kind > 173)
4672                        kind = 173;
4673                     jjCheckNAdd(545);
4674                  }
4675                  else if ((0x100002600L & l) != 0L)
4676                     jjCheckNAddStates(100, 103);
4677                  else if (curChar == 58)
4678                     jjstateSet[jjnewStateCnt++] = 544;
4679                  else if (curChar == 40)
4680                     jjstateSet[jjnewStateCnt++] = 25;
4681                  if ((0x3ff600000000000L & l) != 0L)
4682                     jjCheckNAddTwoStates(542, 543);
4683                  else if (curChar == 58)
4684                     jjstateSet[jjnewStateCnt++] = 541;
4685                  if ((0x3ff600000000000L & l) != 0L)
4686                     jjCheckNAddTwoStates(539, 540);
4687                  break;
4688               case 490:
4689                  if ((0x3ff600000000000L & l) != 0L)
4690                  {
4691                     if (kind > 173)
4692                        kind = 173;
4693                     jjCheckNAdd(545);
4694                  }
4695                  else if (curChar == 58)
4696                     jjstateSet[jjnewStateCnt++] = 544;
4697                  if ((0x3ff600000000000L & l) != 0L)
4698                     jjCheckNAddTwoStates(542, 543);
4699                  else if (curChar == 58)
4700                     jjstateSet[jjnewStateCnt++] = 541;
4701                  if ((0x3ff600000000000L & l) != 0L)
4702                     jjCheckNAddTwoStates(539, 540);
4703                  break;
4704               case 0:
4705                  if (curChar == 58)
4706                     jjCheckNAddTwoStates(4, 5);
4707                  break;
4708               case 1:
4709                  if (curChar == 58)
4710                     jjCheckNAddTwoStates(2, 21);
4711                  break;
4712               case 2:
4713                  if ((0xfbffffffffffffffL & l) != 0L)
4714                     jjCheckNAddTwoStates(2, 21);
4715                  break;
4716               case 3:
4717                  if (curChar == 41)
4718                     jjCheckNAddStates(0, 3);
4719                  break;
4720               case 4:
4721                  if (curChar == 40)
4722                     jjstateSet[jjnewStateCnt++] = 1;
4723                  break;
4724               case 5:
4725                  if ((0x100002600L & l) != 0L)
4726                     jjCheckNAddStates(0, 3);
4727                  break;
4728               case 21:
4729                  if (curChar == 58)
4730                     jjstateSet[jjnewStateCnt++] = 3;
4731                  break;
4732               case 22:
4733                  if (curChar == 58)
4734                     jjstateSet[jjnewStateCnt++] = 0;
4735                  break;
4736               case 25:
4737                  if (curChar == 58)
4738                     jjCheckNAddTwoStates(26, 36);
4739                  break;
4740               case 26:
4741                  if ((0xfbffffffffffffffL & l) != 0L)
4742                     jjCheckNAddTwoStates(26, 36);
4743                  break;
4744               case 27:
4745                  if (curChar == 41)
4746                     jjCheckNAddStates(100, 103);
4747                  break;
4748               case 28:
4749                  if (curChar == 40)
4750                     jjstateSet[jjnewStateCnt++] = 25;
4751                  break;
4752               case 29:
4753                  if ((0x100002600L & l) != 0L)
4754                     jjCheckNAddStates(100, 103);
4755                  break;
4756               case 30:
4757                  if (curChar == 34)
4758                     jjCheckNAddTwoStates(31, 32);
4759                  break;
4760               case 31:
4761                  if ((0xfffffffbffffffffL & l) != 0L)
4762                     jjCheckNAddTwoStates(31, 32);
4763                  break;
4764               case 32:
4765                  if (curChar == 34 && kind > 80)
4766                     kind = 80;
4767                  break;
4768               case 33:
4769                  if (curChar == 39)
4770                     jjCheckNAddTwoStates(34, 35);
4771                  break;
4772               case 34:
4773                  if ((0xffffff7fffffffffL & l) != 0L)
4774                     jjCheckNAddTwoStates(34, 35);
4775                  break;
4776               case 35:
4777                  if (curChar == 39 && kind > 80)
4778                     kind = 80;
4779                  break;
4780               case 36:
4781                  if (curChar == 58)
4782                     jjstateSet[jjnewStateCnt++] = 27;
4783                  break;
4784               case 39:
4785                  if (curChar == 58)
4786                     jjCheckNAddTwoStates(40, 46);
4787                  break;
4788               case 40:
4789                  if ((0xfbffffffffffffffL & l) != 0L)
4790                     jjCheckNAddTwoStates(40, 46);
4791                  break;
4792               case 41:
4793                  if (curChar == 41)
4794                     jjCheckNAddStates(104, 106);
4795                  break;
4796               case 42:
4797                  if (curChar == 40)
4798                     jjstateSet[jjnewStateCnt++] = 39;
4799                  break;
4800               case 43:
4801                  if ((0x100002600L & l) != 0L)
4802                     jjCheckNAddStates(104, 106);
4803                  break;
4804               case 46:
4805                  if (curChar == 58)
4806                     jjstateSet[jjnewStateCnt++] = 41;
4807                  break;
4808               case 52:
4809                  if (curChar == 58)
4810                     jjCheckNAddTwoStates(53, 58);
4811                  break;
4812               case 53:
4813                  if ((0xfbffffffffffffffL & l) != 0L)
4814                     jjCheckNAddTwoStates(53, 58);
4815                  break;
4816               case 54:
4817                  if (curChar == 41)
4818                     jjCheckNAddStates(107, 109);
4819                  break;
4820               case 55:
4821                  if (curChar == 40)
4822                     jjstateSet[jjnewStateCnt++] = 52;
4823                  break;
4824               case 56:
4825                  if ((0x100002600L & l) != 0L)
4826                     jjCheckNAddStates(107, 109);
4827                  break;
4828               case 57:
4829                  if (curChar == 36 && kind > 136)
4830                     kind = 136;
4831                  break;
4832               case 58:
4833                  if (curChar == 58)
4834                     jjstateSet[jjnewStateCnt++] = 54;
4835                  break;
4836               case 62:
4837                  if (curChar == 58)
4838                     jjCheckNAddTwoStates(63, 68);
4839                  break;
4840               case 63:
4841                  if ((0xfbffffffffffffffL & l) != 0L)
4842                     jjCheckNAddTwoStates(63, 68);
4843                  break;
4844               case 64:
4845                  if (curChar == 41)
4846                     jjCheckNAddStates(110, 112);
4847                  break;
4848               case 65:
4849                  if (curChar == 40)
4850                     jjstateSet[jjnewStateCnt++] = 62;
4851                  break;
4852               case 66:
4853                  if ((0x100002600L & l) != 0L)
4854                     jjCheckNAddStates(110, 112);
4855                  break;
4856               case 67:
4857                  if (curChar == 36 && kind > 137)
4858                     kind = 137;
4859                  break;
4860               case 68:
4861                  if (curChar == 58)
4862                     jjstateSet[jjnewStateCnt++] = 64;
4863                  break;
4864               case 71:
4865                  if (curChar == 41)
4866                     jjCheckNAddTwoStates(75, 76);
4867                  break;
4868               case 72:
4869                  if (curChar == 58)
4870                     jjCheckNAddTwoStates(73, 79);
4871                  break;
4872               case 73:
4873                  if ((0xfbffffffffffffffL & l) != 0L)
4874                     jjCheckNAddTwoStates(73, 79);
4875                  break;
4876               case 74:
4877                  if (curChar == 41)
4878                     jjCheckNAddStates(97, 99);
4879                  break;
4880               case 75:
4881                  if (curChar == 40)
4882                     jjstateSet[jjnewStateCnt++] = 72;
4883                  break;
4884               case 76:
4885                  if ((0x100002600L & l) != 0L)
4886                     jjCheckNAddStates(97, 99);
4887                  break;
4888               case 79:
4889                  if (curChar == 58)
4890                     jjstateSet[jjnewStateCnt++] = 74;
4891                  break;
4892               case 81:
4893                  if (curChar == 58)
4894                     jjCheckNAddTwoStates(82, 87);
4895                  break;
4896               case 82:
4897                  if ((0xfbffffffffffffffL & l) != 0L)
4898                     jjCheckNAddTwoStates(82, 87);
4899                  break;
4900               case 83:
4901                  if (curChar == 41)
4902                     jjCheckNAddStates(113, 115);
4903                  break;
4904               case 84:
4905                  if (curChar == 40)
4906                     jjstateSet[jjnewStateCnt++] = 81;
4907                  break;
4908               case 85:
4909                  if ((0x100002600L & l) != 0L)
4910                     jjCheckNAddStates(113, 115);
4911                  break;
4912               case 87:
4913                  if (curChar == 58)
4914                     jjstateSet[jjnewStateCnt++] = 83;
4915                  break;
4916               case 95:
4917                  if (curChar == 42)
4918                     jjstateSet[jjnewStateCnt++] = 96;
4919                  break;
4920               case 96:
4921                  if (curChar == 58)
4922                     jjstateSet[jjnewStateCnt++] = 97;
4923                  break;
4924               case 98:
4925                  if ((0x3ff600000000000L & l) == 0L)
4926                     break;
4927                  if (kind > 171)
4928                     kind = 171;
4929                  jjstateSet[jjnewStateCnt++] = 98;
4930                  break;
4931               case 99:
4932                  if (curChar == 34)
4933                     jjCheckNAddTwoStates(100, 101);
4934                  break;
4935               case 100:
4936                  if ((0xfffffffbffffffffL & l) != 0L)
4937                     jjCheckNAddTwoStates(100, 101);
4938                  break;
4939               case 101:
4940                  if (curChar == 34 && kind > 172)
4941                     kind = 172;
4942                  break;
4943               case 102:
4944                  if (curChar == 39)
4945                     jjCheckNAddTwoStates(103, 104);
4946                  break;
4947               case 103:
4948                  if ((0xffffff7fffffffffL & l) != 0L)
4949                     jjCheckNAddTwoStates(103, 104);
4950                  break;
4951               case 104:
4952                  if (curChar == 39 && kind > 172)
4953                     kind = 172;
4954                  break;
4955               case 107:
4956                  if (curChar == 58)
4957                     jjCheckNAddTwoStates(108, 120);
4958                  break;
4959               case 108:
4960                  if ((0xfbffffffffffffffL & l) != 0L)
4961                     jjCheckNAddTwoStates(108, 120);
4962                  break;
4963               case 109:
4964                  if (curChar == 41)
4965                     jjCheckNAddStates(116, 118);
4966                  break;
4967               case 110:
4968                  if (curChar == 40)
4969                     jjstateSet[jjnewStateCnt++] = 107;
4970                  break;
4971               case 111:
4972                  if ((0x100002600L & l) != 0L)
4973                     jjCheckNAddStates(116, 118);
4974                  break;
4975               case 120:
4976                  if (curChar == 58)
4977                     jjstateSet[jjnewStateCnt++] = 109;
4978                  break;
4979               case 127:
4980                  if (curChar == 58)
4981                     jjCheckNAddTwoStates(128, 154);
4982                  break;
4983               case 128:
4984                  if ((0xfbffffffffffffffL & l) != 0L)
4985                     jjCheckNAddTwoStates(128, 154);
4986                  break;
4987               case 129:
4988                  if (curChar == 41)
4989                     jjCheckNAddStates(119, 121);
4990                  break;
4991               case 130:
4992                  if (curChar == 40)
4993                     jjstateSet[jjnewStateCnt++] = 127;
4994                  break;
4995               case 131:
4996                  if ((0x100002600L & l) != 0L)
4997                     jjCheckNAddStates(119, 121);
4998                  break;
4999               case 133:
5000                  if (curChar == 58)
5001                     jjCheckNAddTwoStates(134, 147);
5002                  break;
5003               case 134:
5004                  if ((0xfbffffffffffffffL & l) != 0L)
5005                     jjCheckNAddTwoStates(134, 147);
5006                  break;
5007               case 135:
5008                  if (curChar == 41)
5009                     jjCheckNAddStates(122, 124);
5010                  break;
5011               case 136:
5012                  if (curChar == 40)
5013                     jjstateSet[jjnewStateCnt++] = 133;
5014                  break;
5015               case 137:
5016                  if ((0x100002600L & l) != 0L)
5017                     jjCheckNAddStates(122, 124);
5018                  break;
5019               case 147:
5020                  if (curChar == 58)
5021                     jjstateSet[jjnewStateCnt++] = 135;
5022                  break;
5023               case 154:
5024                  if (curChar == 58)
5025                     jjstateSet[jjnewStateCnt++] = 129;
5026                  break;
5027               case 161:
5028                  if (curChar == 58)
5029                     jjCheckNAddTwoStates(162, 175);
5030                  break;
5031               case 162:
5032                  if ((0xfbffffffffffffffL & l) != 0L)
5033                     jjCheckNAddTwoStates(162, 175);
5034                  break;
5035               case 163:
5036                  if (curChar == 41)
5037                     jjCheckNAddStates(125, 127);
5038                  break;
5039               case 164:
5040                  if (curChar == 40)
5041                     jjstateSet[jjnewStateCnt++] = 161;
5042                  break;
5043               case 165:
5044                  if ((0x100002600L & l) != 0L)
5045                     jjCheckNAddStates(125, 127);
5046                  break;
5047               case 175:
5048                  if (curChar == 58)
5049                     jjstateSet[jjnewStateCnt++] = 163;
5050                  break;
5051               case 182:
5052                  if (curChar == 58)
5053                     jjCheckNAddTwoStates(183, 195);
5054                  break;
5055               case 183:
5056                  if ((0xfbffffffffffffffL & l) != 0L)
5057                     jjCheckNAddTwoStates(183, 195);
5058                  break;
5059               case 184:
5060                  if (curChar == 41)
5061                     jjCheckNAddStates(128, 130);
5062                  break;
5063               case 185:
5064                  if (curChar == 40)
5065                     jjstateSet[jjnewStateCnt++] = 182;
5066                  break;
5067               case 186:
5068                  if ((0x100002600L & l) != 0L)
5069                     jjCheckNAddStates(128, 130);
5070                  break;
5071               case 190:
5072                  if (curChar == 45)
5073                     jjstateSet[jjnewStateCnt++] = 189;
5074                  break;
5075               case 195:
5076                  if (curChar == 58)
5077                     jjstateSet[jjnewStateCnt++] = 184;
5078                  break;
5079               case 202:
5080                  if (curChar == 58)
5081                     jjCheckNAddTwoStates(203, 215);
5082                  break;
5083               case 203:
5084                  if ((0xfbffffffffffffffL & l) != 0L)
5085                     jjCheckNAddTwoStates(203, 215);
5086                  break;
5087               case 204:
5088                  if (curChar == 41)
5089                     jjCheckNAddStates(131, 133);
5090                  break;
5091               case 205:
5092                  if (curChar == 40)
5093                     jjstateSet[jjnewStateCnt++] = 202;
5094                  break;
5095               case 206:
5096                  if ((0x100002600L & l) != 0L)
5097                     jjCheckNAddStates(131, 133);
5098                  break;
5099               case 215:
5100                  if (curChar == 58)
5101                     jjstateSet[jjnewStateCnt++] = 204;
5102                  break;
5103               case 222:
5104                  if (curChar == 58)
5105                     jjCheckNAddTwoStates(223, 249);
5106                  break;
5107               case 223:
5108                  if ((0xfbffffffffffffffL & l) != 0L)
5109                     jjCheckNAddTwoStates(223, 249);
5110                  break;
5111               case 224:
5112                  if (curChar == 41)
5113                     jjCheckNAddStates(134, 136);
5114                  break;
5115               case 225:
5116                  if (curChar == 40)
5117                     jjstateSet[jjnewStateCnt++] = 222;
5118                  break;
5119               case 226:
5120                  if ((0x100002600L & l) != 0L)
5121                     jjCheckNAddStates(134, 136);
5122                  break;
5123               case 228:
5124                  if (curChar == 58)
5125                     jjCheckNAddTwoStates(229, 242);
5126                  break;
5127               case 229:
5128                  if ((0xfbffffffffffffffL & l) != 0L)
5129                     jjCheckNAddTwoStates(229, 242);
5130                  break;
5131               case 230:
5132                  if (curChar == 41)
5133                     jjCheckNAddStates(137, 139);
5134                  break;
5135               case 231:
5136                  if (curChar == 40)
5137                     jjstateSet[jjnewStateCnt++] = 228;
5138                  break;
5139               case 232:
5140                  if ((0x100002600L & l) != 0L)
5141                     jjCheckNAddStates(137, 139);
5142                  break;
5143               case 242:
5144                  if (curChar == 58)
5145                     jjstateSet[jjnewStateCnt++] = 230;
5146                  break;
5147               case 249:
5148                  if (curChar == 58)
5149                     jjstateSet[jjnewStateCnt++] = 224;
5150                  break;
5151               case 256:
5152                  if (curChar == 58)
5153                     jjCheckNAddTwoStates(257, 281);
5154                  break;
5155               case 257:
5156                  if ((0xfbffffffffffffffL & l) != 0L)
5157                     jjCheckNAddTwoStates(257, 281);
5158                  break;
5159               case 258:
5160                  if (curChar == 41)
5161                     jjCheckNAddStates(140, 142);
5162                  break;
5163               case 259:
5164                  if (curChar == 40)
5165                     jjstateSet[jjnewStateCnt++] = 256;
5166                  break;
5167               case 260:
5168                  if ((0x100002600L & l) != 0L)
5169                     jjCheckNAddStates(140, 142);
5170                  break;
5171               case 262:
5172                  if (curChar == 58)
5173                     jjCheckNAddTwoStates(263, 274);
5174                  break;
5175               case 263:
5176                  if ((0xfbffffffffffffffL & l) != 0L)
5177                     jjCheckNAddTwoStates(263, 274);
5178                  break;
5179               case 264:
5180                  if (curChar == 41)
5181                     jjCheckNAddStates(143, 145);
5182                  break;
5183               case 265:
5184                  if (curChar == 40)
5185                     jjstateSet[jjnewStateCnt++] = 262;
5186                  break;
5187               case 266:
5188                  if ((0x100002600L & l) != 0L)
5189                     jjCheckNAddStates(143, 145);
5190                  break;
5191               case 274:
5192                  if (curChar == 58)
5193                     jjstateSet[jjnewStateCnt++] = 264;
5194                  break;
5195               case 281:
5196                  if (curChar == 58)
5197                     jjstateSet[jjnewStateCnt++] = 258;
5198                  break;
5199               case 288:
5200                  if (curChar == 58)
5201                     jjCheckNAddTwoStates(289, 314);
5202                  break;
5203               case 289:
5204                  if ((0xfbffffffffffffffL & l) != 0L)
5205                     jjCheckNAddTwoStates(289, 314);
5206                  break;
5207               case 290:
5208                  if (curChar == 41)
5209                     jjCheckNAddStates(146, 148);
5210                  break;
5211               case 291:
5212                  if (curChar == 40)
5213                     jjstateSet[jjnewStateCnt++] = 288;
5214                  break;
5215               case 292:
5216                  if ((0x100002600L & l) != 0L)
5217                     jjCheckNAddStates(146, 148);
5218                  break;
5219               case 294:
5220                  if (curChar == 58)
5221                     jjCheckNAddTwoStates(295, 307);
5222                  break;
5223               case 295:
5224                  if ((0xfbffffffffffffffL & l) != 0L)
5225                     jjCheckNAddTwoStates(295, 307);
5226                  break;
5227               case 296:
5228                  if (curChar == 41)
5229                     jjCheckNAddStates(149, 151);
5230                  break;
5231               case 297:
5232                  if (curChar == 40)
5233                     jjstateSet[jjnewStateCnt++] = 294;
5234                  break;
5235               case 298:
5236                  if ((0x100002600L & l) != 0L)
5237                     jjCheckNAddStates(149, 151);
5238                  break;
5239               case 307:
5240                  if (curChar == 58)
5241                     jjstateSet[jjnewStateCnt++] = 296;
5242                  break;
5243               case 314:
5244                  if (curChar == 58)
5245                     jjstateSet[jjnewStateCnt++] = 290;
5246                  break;
5247               case 322:
5248                  if (curChar == 58)
5249                     jjCheckNAddTwoStates(323, 340);
5250                  break;
5251               case 323:
5252                  if ((0xfbffffffffffffffL & l) != 0L)
5253                     jjCheckNAddTwoStates(323, 340);
5254                  break;
5255               case 324:
5256                  if (curChar == 41)
5257                     jjCheckNAddStates(152, 154);
5258                  break;
5259               case 325:
5260                  if (curChar == 40)
5261                     jjstateSet[jjnewStateCnt++] = 322;
5262                  break;
5263               case 326:
5264                  if ((0x100002600L & l) != 0L)
5265                     jjCheckNAddStates(152, 154);
5266                  break;
5267               case 328:
5268                  if (curChar == 58)
5269                     jjCheckNAddTwoStates(329, 335);
5270                  break;
5271               case 329:
5272                  if ((0xfbffffffffffffffL & l) != 0L)
5273                     jjCheckNAddTwoStates(329, 335);
5274                  break;
5275               case 330:
5276                  if (curChar == 41)
5277                     jjCheckNAddStates(155, 157);
5278                  break;
5279               case 331:
5280                  if (curChar == 40)
5281                     jjstateSet[jjnewStateCnt++] = 328;
5282                  break;
5283               case 332:
5284                  if ((0x100002600L & l) != 0L)
5285                     jjCheckNAddStates(155, 157);
5286                  break;
5287               case 335:
5288                  if (curChar == 58)
5289                     jjstateSet[jjnewStateCnt++] = 330;
5290                  break;
5291               case 340:
5292                  if (curChar == 58)
5293                     jjstateSet[jjnewStateCnt++] = 324;
5294                  break;
5295               case 346:
5296                  if (curChar == 58)
5297                     jjCheckNAddTwoStates(347, 360);
5298                  break;
5299               case 347:
5300                  if ((0xfbffffffffffffffL & l) != 0L)
5301                     jjCheckNAddTwoStates(347, 360);
5302                  break;
5303               case 348:
5304                  if (curChar == 41)
5305                     jjCheckNAddStates(158, 160);
5306                  break;
5307               case 349:
5308                  if (curChar == 40)
5309                     jjstateSet[jjnewStateCnt++] = 346;
5310                  break;
5311               case 350:
5312                  if ((0x100002600L & l) != 0L)
5313                     jjCheckNAddStates(158, 160);
5314                  break;
5315               case 352:
5316                  if (curChar == 58)
5317                     jjCheckNAddTwoStates(353, 358);
5318                  break;
5319               case 353:
5320                  if ((0xfbffffffffffffffL & l) != 0L)
5321                     jjCheckNAddTwoStates(353, 358);
5322                  break;
5323               case 354:
5324                  if (curChar == 41)
5325                     jjCheckNAddStates(161, 163);
5326                  break;
5327               case 355:
5328                  if (curChar == 40)
5329                     jjstateSet[jjnewStateCnt++] = 352;
5330                  break;
5331               case 356:
5332                  if ((0x100002600L & l) != 0L)
5333                     jjCheckNAddStates(161, 163);
5334        &