KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > steadystate > css > parser > SACParserTokenManager


1 /* Generated By:JavaCC: Do not edit this line. SACParserTokenManager.java */
2 package com.steadystate.css.parser;
3 import java.io.*;
4 import java.net.*;
5 import java.util.*;
6 import org.w3c.css.sac.*;
7 import com.steadystate.css.parser.selectors.*;
8
9 public class SACParserTokenManager implements SACParserConstants
10 {
11     private boolean _quiet = true;
12 /*
13   private int getLastNumPos(StringBuffer sb) {
14     int i;
15     for( i = 0; i < sb.length(); i++ )
16       if( Character.isLetter( sb.charAt( i ) ) )
17         break;
18     return i - 1;
19   }
20 */

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