|
1
2 package com.versant.core.ejb.query;
3
4 public class EJBQLParserTokenManager implements EJBQLParserConstants
5 {
6 public java.io.PrintStream  debugStream = System.out;
7 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
8 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
9 {
10 switch (pos)
11 {
12 case 0:
13 if ((active0 & 0x4000L) != 0L)
14 return 44;
15 return -1;
16 default :
17 return -1;
18 }
19 }
20 private final int jjStartNfa_0(int pos, long active0, long active1)
21 {
22 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
23 }
24 private final int jjStopAtPos(int pos, int kind)
25 {
26 jjmatchedKind = kind;
27 jjmatchedPos = pos;
28 return pos + 1;
29 }
30 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
31 {
32 jjmatchedKind = kind;
33 jjmatchedPos = pos;
34 try { curChar = input_stream.readChar(); }
35 catch(java.io.IOException e) { return pos + 1; }
36 return jjMoveNfa_0(state, pos + 1);
37 }
38 private final int jjMoveStringLiteralDfa0_0()
39 {
40 switch(curChar)
41 {
42 case 40:
43 return jjStopAtPos(0, 6);
44 case 41:
45 return jjStopAtPos(0, 7);
46 case 42:
47 return jjStopAtPos(0, 95);
48 case 43:
49 return jjStopAtPos(0, 93);
50 case 44:
51 return jjStopAtPos(0, 13);
52 case 45:
53 return jjStopAtPos(0, 94);
54 case 46:
55 return jjStartNfaWithStates_0(0, 14, 44);
56 case 47:
57 return jjStopAtPos(0, 96);
58 case 58:
59 return jjStopAtPos(0, 16);
60 case 59:
61 return jjStopAtPos(0, 12);
62 case 60:
63 jjmatchedKind = 18;
64 return jjMoveStringLiteralDfa1_0(0x480000L);
65 case 61:
66 return jjStopAtPos(0, 17);
67 case 62:
68 jjmatchedKind = 20;
69 return jjMoveStringLiteralDfa1_0(0x200000L);
70 case 63:
71 return jjStopAtPos(0, 15);
72 case 91:
73 return jjStopAtPos(0, 10);
74 case 93:
75 return jjStopAtPos(0, 11);
76 case 123:
77 return jjStopAtPos(0, 8);
78 case 125:
79 return jjStopAtPos(0, 9);
80 default :
81 return jjMoveNfa_0(3, 0);
82 }
83 }
84 private final int jjMoveStringLiteralDfa1_0(long active0)
85 {
86 try { curChar = input_stream.readChar(); }
87 catch(java.io.IOException e) {
88 jjStopStringLiteralDfa_0(0, active0, 0L);
89 return 1;
90 }
91 switch(curChar)
92 {
93 case 61:
94 if ((active0 & 0x80000L) != 0L)
95 return jjStopAtPos(1, 19);
96 else if ((active0 & 0x200000L) != 0L)
97 return jjStopAtPos(1, 21);
98 break;
99 case 62:
100 if ((active0 & 0x400000L) != 0L)
101 return jjStopAtPos(1, 22);
102 break;
103 default :
104 break;
105 }
106 return jjStartNfa_0(0, active0, 0L);
107 }
108 private final void jjCheckNAdd(int state)
109 {
110 if (jjrounds[state] != jjround)
111 {
112 jjstateSet[jjnewStateCnt++] = state;
113 jjrounds[state] = jjround;
114 }
115 }
116 private final void jjAddStates(int start, int end)
117 {
118 do {
119 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
120 } while (start++ != end);
121 }
122 private final void jjCheckNAddTwoStates(int state1, int state2)
123 {
124 jjCheckNAdd(state1);
125 jjCheckNAdd(state2);
126 }
127 private final void jjCheckNAddStates(int start, int end)
128 {
129 do {
130 jjCheckNAdd(jjnextStates[start]);
131 } while (start++ != end);
132 }
133 private final void jjCheckNAddStates(int start)
134 {
135 jjCheckNAdd(jjnextStates[start]);
136 jjCheckNAdd(jjnextStates[start + 1]);
137 }
138 static final long[] jjbitVec0 = {
139 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
140 };
141 static final long[] jjbitVec2 = {
142 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
143 };
144 private final int jjMoveNfa_0(int startState, int curPos)
145 {
146 int[] nextStates;
147 int startsAt = 0;
148 jjnewStateCnt = 567;
149 int i = 1;
150 jjstateSet[0] = startState;
151 int j, kind = 0x7fffffff;
152 for (;;)
153 {
154 if (++jjround == 0x7fffffff)
155 ReInitRounds();
156 if (curChar < 64)
157 {
158 long l = 1L << curChar;
159 MatchLoop: do
160 {
161 switch(jjstateSet[--i])
162 {
163 case 3:
164 if ((0x3ff000000000000L & l) != 0L)
165 jjCheckNAddStates(0, 6);
166 else if (curChar == 34)
167 jjCheckNAddStates(7, 9);
168 else if (curChar == 39)
169 jjCheckNAddStates(10, 12);
170 else if (curChar == 46)
171 jjCheckNAdd(44);
172 if ((0x3fe000000000000L & l) != 0L)
173 {
174 if (kind > 81)
175 kind = 81;
176 jjCheckNAddTwoStates(41, 42);
177 }
178 else if (curChar == 48)
179 {
180 if (kind > 83)
181 kind = 83;
182 jjCheckNAddTwoStates(563, 566);
183 }
184 break;
185 case 40:
186 if ((0x3fe000000000000L & l) == 0L)
187 break;
188 if (kind > 81)
189 kind = 81;
190 jjCheckNAddTwoStates(41, 42);
191 break;
192 case 41:
193 if ((0x3ff000000000000L & l) == 0L)
194 break;
195 if (kind > 81)
196 kind = 81;
197 jjCheckNAddTwoStates(41, 42);
198 break;
199 case 43:
200 if (curChar == 46)
201 jjCheckNAdd(44);
202 break;
203 case 44:
204 if ((0x3ff000000000000L & l) == 0L)
205 break;
206 if (kind > 84)
207 kind = 84;
208 jjCheckNAddStates(13, 15);
209 break;
210 case 46:
211 if ((0x280000000000L & l) != 0L)
212 jjCheckNAdd(47);
213 break;
214 case 47:
215 if ((0x3ff000000000000L & l) == 0L)
216 break;
217 if (kind > 84)
218 kind = 84;
219 jjCheckNAddTwoStates(47, 48);
220 break;
221 case 49:
222 if (curChar == 39)
223 jjCheckNAddStates(10, 12);
224 break;
225 case 50:
226 if ((0xffffff7fffffdbffL & l) != 0L)
227 jjCheckNAddStates(10, 12);
228 break;
229 case 52:
230 if ((0x8400000000L & l) != 0L)
231 jjCheckNAddStates(10, 12);
232 break;
233 case 53:
234 if (curChar == 39 && kind > 86)
235 kind = 86;
236 break;
237 case 54:
238 if ((0xff000000000000L & l) != 0L)
239 jjCheckNAddStates(16, 19);
240 break;
241 case 55:
242 if ((0xff000000000000L & l) != 0L)
243 jjCheckNAddStates(10, 12);
244 break;
245 case 56:
246 if ((0xf000000000000L & l) != 0L)
247 jjstateSet[jjnewStateCnt++] = 57;
248 break;
249 case 57:
250 if ((0xff000000000000L & l) != 0L)
251 jjCheckNAdd(55);
252 break;
253 case 58:
254 if (curChar == 34)
255 jjCheckNAddStates(7, 9);
256 break;
257 case 59:
258 if ((0xfffffffbffffdbffL & l) != 0L)
259 jjCheckNAddStates(7, 9);
260 break;
261 case 61:
262 if ((0x8400000000L & l) != 0L)
263 jjCheckNAddStates(7, 9);
264 break;
265 case 62:
266 if (curChar == 34 && kind > 89)
267 kind = 89;
268 break;
269 case 63:
270 if ((0xff000000000000L & l) != 0L)
271 jjCheckNAddStates(20, 23);
272 break;
273 case 64:
274 if ((0xff000000000000L & l) != 0L)
275 jjCheckNAddStates(7, 9);
276 break;
277 case 65:
278 if ((0xf000000000000L & l) != 0L)
279 jjstateSet[jjnewStateCnt++] = 66;
280 break;
281 case 66:
282 if ((0xff000000000000L & l) != 0L)
283 jjCheckNAdd(64);
284 break;
285 case 68:
286 if ((0x3ff000000000000L & l) == 0L)
287 break;
288 if (kind > 90)
289 kind = 90;
290 jjstateSet[jjnewStateCnt++] = 68;
291 break;
292 case 69:
293 if ((0x3ff000000000000L & l) != 0L)
294 jjCheckNAddStates(0, 6);
295 break;
296 case 70:
297 if ((0x3ff000000000000L & l) != 0L)
298 jjCheckNAddTwoStates(70, 71);
299 break;
300 case 71:
301 if (curChar != 46)
302 break;
303 if (kind > 84)
304 kind = 84;
305 jjCheckNAddStates(24, 26);
306 break;
307 case 72:
308 if ((0x3ff000000000000L & l) == 0L)
309 break;
310 if (kind > 84)
311 kind = 84;
312 jjCheckNAddStates(24, 26);
313 break;
314 case 74:
315 if ((0x280000000000L & l) != 0L)
316 jjCheckNAdd(75);
317 break;
318 case 75:
319 if ((0x3ff000000000000L & l) == 0L)
320 break;
321 if (kind > 84)
322 kind = 84;
323 jjCheckNAddTwoStates(75, 48);
324 break;
325 case 76:
326 if ((0x3ff000000000000L & l) != 0L)
327 jjCheckNAddTwoStates(76, 77);
328 break;
329 case 78:
330 if ((0x280000000000L & l) != 0L)
331 jjCheckNAdd(79);
332 break;
333 case 79:
334 if ((0x3ff000000000000L & l) == 0L)
335 break;
336 if (kind > 84)
337 kind = 84;
338 jjCheckNAddTwoStates(79, 48);
339 break;
340 case 80:
341 if ((0x3ff000000000000L & l) != 0L)
342 jjCheckNAddStates(27, 29);
343 break;
344 case 82:
345 if ((0x280000000000L & l) != 0L)
346 jjCheckNAdd(83);
347 break;
348 case 83:
349 if ((0x3ff000000000000L & l) != 0L)
350 jjCheckNAddTwoStates(83, 48);
351 break;
352 case 562:
353 if (curChar != 48)
354 break;
355 if (kind > 83)
356 kind = 83;
357 jjCheckNAddTwoStates(563, 566);
358 break;
359 case 564:
360 if ((0x3ff000000000000L & l) == 0L)
361 break;
362 if (kind > 82)
363 kind = 82;
364 jjAddStates(30, 31);
365 break;
366 case 566:
367 if ((0xff000000000000L & l) == 0L)
368 break;
369 if (kind > 83)
370 kind = 83;
371 jjCheckNAdd(566);
372 break;
373 default : break;
374 }
375 } while(i != startsAt);
376 }
377 else if (curChar < 128)
378 {
379 long l = 1L << (curChar & 077);
380 MatchLoop: do
381 {
382 switch(jjstateSet[--i])
383 {
384 case 3:
385 if ((0x7fffffe87fffffeL & l) != 0L)
386 {
387 if (kind > 90)
388 kind = 90;
389 jjCheckNAdd(68);
390 }
391 if (curChar == 116)
392 jjAddStates(32, 34);
393 else if (curChar == 84)
394 jjAddStates(35, 36);
395 else if (curChar == 101)
396 jjAddStates(37, 39);
397 else if (curChar == 69)
398 jjAddStates(40, 42);
399 else if (curChar == 98)
400 jjAddStates(43, 46);
401 else if (curChar == 66)
402 jjAddStates(47, 50);
403 else if (curChar == 99)
404 jjAddStates(51, 55);
405 else if (curChar == 67)
406 jjAddStates(56, 60);
407 else if (curChar == 109)
408 jjAddStates(61, 64);
409 else if (curChar == 77)
410 jjAddStates(65, 68);
411 else if (curChar == 110)
412 jjAddStates(69, 71);
413 else if (curChar == 78)
414 jjAddStates(72, 74);
415 else if (curChar == 117)
416 jjAddStates(75, 76);
417 else if (curChar == 85)
418 jjAddStates(77, 78);
419 else if (curChar == 97)
420 jjAddStates(79, 85);
421 else if (curChar == 65)
422 jjAddStates(86, 92);
423 else if (curChar == 105)
424 jjAddStates(93, 95);
425 else if (curChar == 73)
426 jjAddStates(96, 98);
427 else if (curChar == 108)
428 jjAddStates(99, 104);
429 else if (curChar == 76)
430 jjAddStates(105, 110);
431 else if (curChar == 111)
432 jjAddStates(111, 115);
433 else if (curChar == 79)
434 jjAddStates(116, 120);
435 else if (curChar == 100)
436 jjAddStates(121, 123);
437 else if (curChar == 68)
438 jjAddStates(124, 126);
439 else if (curChar == 102)
440 jjAddStates(127, 129);
441 else if (curChar == 70)
442 jjAddStates(130, 131);
443 else if (curChar == 115)
444 jjAddStates(132, 137);
445 else if (curChar == 83)
446 jjAddStates(138, 143);
447 else if (curChar == 104)
448 jjstateSet[jjnewStateCnt++] = 38;
449 else if (curChar == 72)
450 jjstateSet[jjnewStateCnt++] = 32;
451 else if (curChar == 103)
452 jjstateSet[jjnewStateCnt++] = 26;
453 else if (curChar == 71)
454 jjstateSet[jjnewStateCnt++] = 21;
455 else if (curChar == 119)
456 jjstateSet[jjnewStateCnt++] = 16;
457 else if (curChar == 87)
458 jjstateSet[jjnewStateCnt++] = 11;
459 else if (curChar == 106)
460 jjstateSet[jjnewStateCnt++] = 6;
461 else if (curChar == 74)
462 jjstateSet[jjnewStateCnt++] = 2;
463 break;
464 case 0:
465 if (curChar == 78 && kind > 30)
466 kind = 30;
467 break;
468 case 1:
469 if (curChar == 73)
470 jjstateSet[jjnewStateCnt++] = 0;
471 break;
472 case 2:
473 if (curChar == 79)
474 jjstateSet[jjnewStateCnt++] = 1;
475 break;
476 case 4:
477 if (curChar == 110 && kind > 30)
478 kind = 30;
479 break;
480 case 5:
481 if (curChar == 105)
482 jjstateSet[jjnewStateCnt++] = 4;
483 break;
484 case 6:
485 if (curChar == 111)
486 jjstateSet[jjnewStateCnt++] = 5;
487 break;
488 case 7:
489 if (curChar == 106)
490 jjstateSet[jjnewStateCnt++] = 6;
491 break;
492 case 8:
493 if (curChar == 69 && kind > 43)
494 kind = 43;
495 break;
496 case 9:
497 if (curChar == 82)
498 jjstateSet[jjnewStateCnt++] = 8;
499 break;
500 case 10:
501 if (curChar == 69)
502 jjstateSet[jjnewStateCnt++] = 9;
503 break;
504 case 11:
505 if (curChar == 72)
506 jjstateSet[jjnewStateCnt++] = 10;
507 break;
508 case 12:
509 if (curChar == 87)
510 jjstateSet[jjnewStateCnt++] = 11;
511 break;
512 case 13:
513 if (curChar == 101 && kind > 43)
514 kind = 43;
515 break;
516 case 14:
517 if (curChar == 114)
518 jjstateSet[jjnewStateCnt++] = 13;
519 break;
520 case 15:
521 if (curChar == 101)
522 jjstateSet[jjnewStateCnt++] = 14;
523 break;
524 case 16:
525 if (curChar == 104)
526 jjstateSet[jjnewStateCnt++] = 15;
527 break;
528 case 17:
529 if (curChar == 119)
530 jjstateSet[jjnewStateCnt++] = 16;
531 break;
532 case 18:
533 if (curChar == 80 && kind > 44)
534 kind = 44;
535 break;
536 case 19:
537 if (curChar == 85)
538 jjstateSet[jjnewStateCnt++] = 18;
539 break;
540 case 20:
541 if (curChar == 79)
542 jjstateSet[jjnewStateCnt++] = 19;
543 break;
544 case 21:
545 if (curChar == 82)
546 jjstateSet[jjnewStateCnt++] = 20;
547 break;
548 case 22:
549 if (curChar == 71)
550 jjstateSet[jjnewStateCnt++] = 21;
551 break;
552 case 23:
553 if (curChar == 112 && kind > 44)
554 kind = 44;
555 break;
556 case 24:
557 if (curChar == 117)
558 jjstateSet[jjnewStateCnt++] = 23;
559 break;
560 case 25:
561 if (curChar == 111)
562 jjstateSet[jjnewStateCnt++] = 24;
563 break;
564 case 26:
565 if (curChar == 114)
566 jjstateSet[jjnewStateCnt++] = 25;
567 break;
568 case 27:
569 if (curChar == 103)
570 jjstateSet[jjnewStateCnt++] = 26;
571 break;
572 case 28:
573 if (curChar == 71 && kind > 46)
574 kind = 46;
575 break;
576 case 29:
577 if (curChar == 78)
578 jjstateSet[jjnewStateCnt++] = 28;
579 break;
580 case 30:
581 if (curChar == 73)
582 jjstateSet[jjnewStateCnt++] = 29;
583 break;
584 case 31:
585 if (curChar == 86)
586 jjstateSet[jjnewStateCnt++] = 30;
587 break;
588 case 32:
589 if (curChar == 65)
590 jjstateSet[jjnewStateCnt++] = 31;
591 break;
592 case 33:
593 if (curChar == 72)
594 jjstateSet[jjnewStateCnt++] = 32;
595 break;
596 case 34:
597 if (curChar == 103 && kind > 46)
598 kind = 46;
599 break;
600 case 35:
601 if (curChar == 110)
602 jjstateSet[jjnewStateCnt++] = 34;
603 break;
604 case 36:
605 if (curChar == 105)
606 jjstateSet[jjnewStateCnt++] = 35;
607 break;
608 case 37:
609 if (curChar == 118)
610 jjstateSet[jjnewStateCnt++] = 36;
611 break;
612 case 38:
613 if (curChar == 97)
614 jjstateSet[jjnewStateCnt++] = 37;
615 break;
616 case 39:
617 if (curChar == 104)
618 jjstateSet[jjnewStateCnt++] = 38;
619 break;
620 case 42:
621 if ((0x100000001000L & l) != 0L && kind > 81)
622 kind = 81;
623 break;
624 case 45:
625 if ((0x2000000020L & l) != 0L)
626 jjAddStates(144, 145);
627 break;
628 case 48:
629 if ((0x5000000050L & l) != 0L && kind > 84)
630 kind = 84;
631 break;
632 case 50:
633 if ((0xffffffffefffffffL & l) != 0L)
634 jjCheckNAddStates(10, 12);
635 break;
636 case 51:
637 if (curChar == 92)
638 jjAddStates(146, 148);
639 break;
640 case 52:
641 if ((0x14404410000000L & l) != 0L)
642 jjCheckNAddStates(10, 12);
643 break;
644 case 59:
645 if ((0xffffffffefffffffL & l) != 0L)
646 jjCheckNAddStates(7, 9);
647 break;
648 case 60:
649 if (curChar == 92)
650 jjAddStates(149, 151);
651 break;
652 case 61:
653 if ((0x14404410000000L & l) != 0L)
654 jjCheckNAddStates(7, 9);
655 break;
656 case 67:
657 case 68:
658 if ((0x7fffffe87fffffeL & l) == 0L)
659 break;
660 if (kind > 90)
661 kind = 90;
662 jjCheckNAdd(68);
663 break;
664 case 73:
665 if ((0x2000000020L & l) != 0L)
666 jjAddStates(152, 153);
667 break;
668 case 77:
669 if ((0x2000000020L & l) != 0L)
670 jjAddStates(154, 155);
671 break;
672 case 81:
673 if ((0x2000000020L & l) != 0L)
674 jjAddStates(156, 157);
675 break;
676 case 84:
677 if (curChar == 83)
678 jjAddStates(138, 143);
679 break;
680 case 85:
681 if (curChar == 84 && kind > 23)
682 kind = 23;
683 break;
684 case 86:
685 if (curChar == 67)
686 jjstateSet[jjnewStateCnt++] = 85;
687 break;
688 case 87:
689 if (curChar == 69)
690 jjstateSet[jjnewStateCnt++] = 86;
691 break;
692 case 88:
693 if (curChar == 76)
694 jjstateSet[jjnewStateCnt++] = 87;
695 break;
696 case 89:
697 if (curChar == 69)
698 jjstateSet[jjnewStateCnt++] = 88;
699 break;
700 case 90:
701 if (curChar == 84 && kind > 35)
702 kind = 35;
703 break;
704 case 91:
705 if (curChar == 69)
706 jjstateSet[jjnewStateCnt++] = 90;
707 break;
708 case 92:
709 if (curChar == 77 && kind > 41)
710 kind = 41;
711 break;
712 case 93:
713 if (curChar == 85)
714 jjstateSet[jjnewStateCnt++] = 92;
715 break;
716 case 94:
717 if (curChar == 69 && kind > 60)
718 kind = 60;
719 break;
720 case 95:
721 if (curChar == 77)
722 jjstateSet[jjnewStateCnt++] = 94;
723 break;
724 case 96:
725 if (curChar == 79)
726 jjstateSet[jjnewStateCnt++] = 95;
727 break;
728 case 97:
729 if (curChar == 71 && kind > 62)
730 kind = 62;
731 break;
732 case 98:
733 if (curChar == 78)
734 jjstateSet[jjnewStateCnt++] = 97;
735 break;
736 case 99:
737 if (curChar == 73)
738 jjstateSet[jjnewStateCnt++] = 98;
739 break;
740 case 100:
741 if (curChar == 82)
742 jjstateSet[jjnewStateCnt++] = 99;
743 break;
744 case 101:
745 if (curChar == 84)
746 jjstateSet[jjnewStateCnt++] = 100;
747 break;
748 case 102:
749 if (curChar == 83)
750 jjstateSet[jjnewStateCnt++] = 101;
751 break;
752 case 103:
753 if (curChar == 66)
754 jjstateSet[jjnewStateCnt++] = 102;
755 break;
756 case 104:
757 if (curChar == 85)
758 jjstateSet[jjnewStateCnt++] = 103;
759 break;
760 case 105:
761 if (curChar == 84 && kind > 72)
762 kind = 72;
763 break;
764 case 106:
765 if (curChar == 82)
766 jjstateSet[jjnewStateCnt++] = 105;
767 break;
768 case 107:
769 if (curChar == 81)
770 jjstateSet[jjnewStateCnt++] = 106;
771 break;
772 case 108:
773 if (curChar == 115)
774 jjAddStates(132, 137);
775 break;
776 case 109:
777 if (curChar == 116 && kind > 23)
778 kind = 23;
779 break;
780 case 110:
781 if (curChar == 99)
782 jjstateSet[jjnewStateCnt++] = 109;
783 break;
784 case 111:
785 if (curChar == 101)
786 jjstateSet[jjnewStateCnt++] = 110;
787 break;
788 case 112:
789 if (curChar == 108)
790 jjstateSet[jjnewStateCnt++] = 111;
791 break;
792 case 113:
793 if (curChar == 101)
794 jjstateSet[jjnewStateCnt++] = 112;
795 break;
796 case 114:
797 if (curChar == 116 && kind > 35)
798 kind = 35;
799 break;
800 case 115:
801 if (curChar == 101)
802 jjstateSet[jjnewStateCnt++] = 114;
803 break;
804 case 116:
805 if (curChar == 109 && kind > 41)
806 kind = 41;
807 break;
808 case 117:
809 if (curChar == 117)
810 jjstateSet[jjnewStateCnt++] = 116;
811 break;
812 case 118:
813 if (curChar == 101 && kind > 60)
814 kind = 60;
815 break;
816 case 119:
817 if (curChar == 109)
818 jjstateSet[jjnewStateCnt++] = 118;
819 break;
820 case 120:
821 if (curChar == 111)
822 jjstateSet[jjnewStateCnt++] = 119;
823 break;
824 case 121:
825 if (curChar == 103 && kind > 62)
826 kind = 62;
827 break;
828 case 122:
829 if (curChar == 110)
830 jjstateSet[jjnewStateCnt++] = 121;
831 break;
832 case 123:
833 if (curChar == 105)
834 jjstateSet[jjnewStateCnt++] = 122;
835 break;
836 case 124:
837 if (curChar == 114)
838 jjstateSet[jjnewStateCnt++] = 123;
839 break;
840 case 125:
841 if (curChar == 116)
842 jjstateSet[jjnewStateCnt++] = 124;
843 break;
844 case 126:
845 if (curChar == 115)
846 jjstateSet[jjnewStateCnt++] = 125;
847 break;
848 case 127:
849 if (curChar == 98)
850 jjstateSet[jjnewStateCnt++] = 126;
851 break;
852 case 128:
853 if (curChar == 117)
854 jjstateSet[jjnewStateCnt++] = 127;
855 break;
856 case 129:
857 if (curChar == 116 && kind > 72)
858 kind = 72;
859 break;
860 case 130:
861 if (curChar == 114)
862 jjstateSet[jjnewStateCnt++] = 129;
863 break;
864 case 131:
865 if (curChar == 113)
866 jjstateSet[jjnewStateCnt++] = 130;
867 break;
868 case 132:
869 if (curChar == 70)
870 jjAddStates(130, 131);
871 break;
872 case 133:
873 if (curChar == 77 && kind > 24)
874 kind = 24;
875 break;
876 case 134:
877 if (curChar == 79)
878 jjstateSet[jjnewStateCnt++] = 133;
879 break;
880 case 135:
881 if (curChar == 82)
882 jjstateSet[jjnewStateCnt++] = 134;
883 break;
884 case 136:
885 if (curChar == 72 && kind > 31)
886 kind = 31;
887 break;
888 case 137:
889 if (curChar == 67)
890 jjstateSet[jjnewStateCnt++] = 136;
891 break;
892 case 138:
893 if (curChar == 84)
894 jjstateSet[jjnewStateCnt++] = 137;
895 break;
896 case 139:
897 if (curChar == 69)
898 jjstateSet[jjnewStateCnt++] = 138;
899 break;
900 case 140:
901 if (curChar == 102)
902 jjAddStates(127, 129);
903 break;
904 case 141:
905 if (curChar == 109 && kind > 24)
906 kind = 24;
907 break;
908 case 142:
909 if (curChar == 111)
910 jjstateSet[jjnewStateCnt++] = 141;
911 break;
912 case 143:
913 if (curChar == 114)
914 jjstateSet[jjnewStateCnt++] = 142;
915 break;
916 case 144:
917 if (curChar == 104 && kind > 31)
918 kind = 31;
919 break;
920 case 145:
921 if (curChar == 99)
922 jjstateSet[jjnewStateCnt++] = 144;
923 break;
924 case 146:
925 if (curChar == 116)
926 jjstateSet[jjnewStateCnt++] = 145;
927 break;
928 case 147:
929 if (curChar == 101)
930 jjstateSet[jjnewStateCnt++] = 146;
931 break;
932 case 148:
933 if (curChar == 101 && kind > 88)
934 kind = 88;
935 break;
936 case 149:
937 if (curChar == 115)
938 jjCheckNAdd(148);
939 break;
940 case 150:
941 if (curChar == 108)
942 jjstateSet[jjnewStateCnt++] = 149;
943 break;
944 case 151:
945 if (curChar == 97)
946 jjstateSet[jjnewStateCnt++] = 150;
947 break;
948 case 152:
949 if (curChar == 68)
950 jjAddStates(124, 126);
951 break;
952 case 153:
953 if (curChar == 84 && kind > 25)
954 kind = 25;
955 break;
956 case 154:
957 if (curChar == 67)
958 jjstateSet[jjnewStateCnt++] = 153;
959 break;
960 case 155:
961 if (curChar == 78)
962 jjstateSet[jjnewStateCnt++] = 154;
963 break;
964 case 156:
965 if (curChar == 73)
966 jjstateSet[jjnewStateCnt++] = 155;
967 break;
968 case 157:
969 if (curChar == 84)
970 jjstateSet[jjnewStateCnt++] = 156;
971 break;
972 case 158:
973 if (curChar == 83)
974 jjstateSet[jjnewStateCnt++] = 157;
975 break;
976 case 159:
977 if (curChar == 73)
978 jjstateSet[jjnewStateCnt++] = 158;
979 break;
980 case 160:
981 if (curChar == 69 && kind > 36)
982 kind = 36;
983 break;
984 case 161:
985 if (curChar == 84)
986 jjstateSet[jjnewStateCnt++] = 160;
987 break;
988 case 162:
989 if (curChar == 69)
990 jjstateSet[jjnewStateCnt++] = 161;
991 break;
992 case 163:
993 if (curChar == 76)
994 jjstateSet[jjnewStateCnt++] = 162;
995 break;
996 case 164:
997 if (curChar == 69)
998 jjstateSet[jjnewStateCnt++] = 163;
999 break;
1000 case 165:
1001 if (curChar == 67 && kind > 80)
1002 kind = 80;
1003 break;
1004 case 166:
1005 if (curChar == 83)
1006 jjstateSet[jjnewStateCnt++] = 165;
1007 break;
1008 case 167:
1009 if (curChar == 69)
1010 jjstateSet[jjnewStateCnt++] = 166;
1011 break;
1012 case 168:
1013 if (curChar == 100)
1014 jjAddStates(121, 123);
1015 break;
1016 case 169:
1017 if (curChar == 116 && kind > 25)
1018 kind = 25;
1019 break;
1020 case 170:
1021 if (curChar == 99)
1022 jjstateSet[jjnewStateCnt++] = 169;
1023 break;
1024 case 171:
1025 if (curChar == 110)
1026 jjstateSet[jjnewStateCnt++] = 170;
1027 break;
1028 case 172:
1029 if (curChar == 105)
1030 jjstateSet[jjnewStateCnt++] = 171;
1031 break;
1032 case 173:
1033 if (curChar == 116)
1034 jjstateSet[jjnewStateCnt++] = 172;
1035 break;
1036 case 174:
1037 if (curChar == 115)
1038 jjstateSet[jjnewStateCnt++] = 173;
1039 break;
1040 case 175:
1041 if (curChar == 105)
1042 jjstateSet[jjnewStateCnt++] = 174;
1043 break;
1044 case 176:
1045 if (curChar == 101 && kind > 36)
1046 kind = 36;
1047 break;
1048 case 177:
1049 if (curChar == 116)
1050 jjstateSet[jjnewStateCnt++] = 176;
1051 break;
1052 case 178:
1053 if (curChar == 101)
1054 jjstateSet[jjnewStateCnt++] = 177;
1055 break;
1056 case 179:
1057 if (curChar == 108)
1058 jjstateSet[jjnewStateCnt++] = 178;
1059 break;
1060 case 180:
1061 if (curChar == 101)
1062 jjstateSet[jjnewStateCnt++] = 179;
1063 break;
1064 case 181:
1065 if (curChar == 99 && kind > 80)
1066 kind = 80;
1067 break;
1068 case 182:
1069 if (curChar == 115)
1070 jjstateSet[jjnewStateCnt++] = 181;
1071 break;
1072 case 183:
1073 if (curChar == 101)
1074 jjstateSet[jjnewStateCnt++] = 182;
1075 break;
1076 case 184:
1077 if (curChar == 79)
1078 jjAddStates(116, 120);
1079 break;
1080 case 185:
1081 if (curChar == 84 && kind > 26)
1082 kind = 26;
1083 break;
1084 case 186:
1085 if (curChar == 67)
1086 jjstateSet[jjnewStateCnt++] = 185;
1087 break;
1088 case 187:
1089 if (curChar == 69)
1090 jjstateSet[jjnewStateCnt++] = 186;
1091 break;
1092 case 188:
1093 if (curChar == 74)
1094 jjstateSet[jjnewStateCnt++] = 187;
1095 break;
1096 case 189:
1097 if (curChar == 66)
1098 jjstateSet[jjnewStateCnt++] = 188;
1099 break;
1100 case 190:
1101 if (curChar == 82 && kind > 28)
1102 kind = 28;
1103 break;
1104 case 191:
1105 if (curChar == 69)
1106 jjstateSet[jjnewStateCnt++] = 190;
1107 break;
1108 case 192:
1109 if (curChar == 84)
1110 jjstateSet[jjnewStateCnt++] = 191;
1111 break;
1112 case 193:
1113 if (curChar == 85)
1114 jjstateSet[jjnewStateCnt++] = 192;
1115 break;
1116 case 194:
1117 if (curChar == 82 && kind > 47)
1118 kind = 47;
1119 break;
1120 case 195:
1121 if (curChar == 70 && kind > 56)
1122 kind = 56;
1123 break;
1124 case 196:
1125 if (curChar == 82 && kind > 78)
1126 kind = 78;
1127 break;
1128 case 197:
1129 if (curChar == 69)
1130 jjstateSet[jjnewStateCnt++] = 196;
1131 break;
1132 case 198:
1133 if (curChar == 68)
1134 jjstateSet[jjnewStateCnt++] = 197;
1135 break;
1136 case 199:
1137 if (curChar == 82)
1138 jjstateSet[jjnewStateCnt++] = 198;
1139 break;
1140 case 200:
1141 if (curChar == 111)
1142 jjAddStates(111, 115);
1143 break;
1144 case 201:
1145 if (curChar == 116 && kind > 26)
1146 kind = 26;
1147 break;
1148 case 202:
1149 if (curChar == 99)
1150 jjstateSet[jjnewStateCnt++] = 201;
1151 break;
1152 case 203:
1153 if (curChar == 101)
1154 jjstateSet[jjnewStateCnt++] = 202;
1155 break;
1156 case 204:
1157 if (curChar == 106)
1158 jjstateSet[jjnewStateCnt++] = 203;
1159 break;
1160 case 205:
1161 if (curChar == 98)
1162 jjstateSet[jjnewStateCnt++] = 204;
1163 break;
1164 case 206:
1165 if (curChar == 114 && kind > 28)
1166 kind = 28;
1167 break;
1168 case 207:
1169 if (curChar == 101)
1170 jjstateSet[jjnewStateCnt++] = 206;
1171 break;
1172 case 208:
1173 if (curChar == 116)
1174 jjstateSet[jjnewStateCnt++] = 207;
1175 break;
1176 case 209:
1177 if (curChar == 117)
1178 jjstateSet[jjnewStateCnt++] = 208;
1179 break;
1180 case 210:
1181 if (curChar == 114 && kind > 47)
1182 kind = 47;
1183 break;
1184 case 211:
1185 if (curChar == 102 && kind > 56)
1186 kind = 56;
1187 break;
1188 case 212:
1189 if (curChar == 114 && kind > 78)
1190 kind = 78;
1191 break;
1192 case 213:
1193 if (curChar == 101)
1194 jjstateSet[jjnewStateCnt++] = 212;
1195 break;
1196 case 214:
1197 if (curChar == 100)
1198 jjstateSet[jjnewStateCnt++] = 213;
1199 break;
1200 case 215:
1201 if (curChar == 114)
1202 jjstateSet[jjnewStateCnt++] = 214;
1203 break;
1204 case 216:
1205 if (curChar == 76)
1206 jjAddStates(105, 110);
1207 break;
1208 case 217:
1209 if (curChar == 84 && kind > 27)
1210 kind = 27;
1211 break;
1212 case 218:
1213 if (curChar == 70)
1214 jjstateSet[jjnewStateCnt++] = 217;
1215 break;
1216 case 219:
1217 if (curChar == 69)
1218 jjstateSet[jjnewStateCnt++] = 218;
1219 break;
1220 case 220:
1221 if (curChar == 69 && kind > 51)
1222 kind = 51;
1223 break;
1224 case 221:
1225 if (curChar == 75)
1226 jjstateSet[jjnewStateCnt++] = 220;
1227 break;
1228 case 222:
1229 if (curChar == 73)
1230 jjstateSet[jjnewStateCnt++] = 221;
1231 break;
1232 case 223:
1233 if (curChar == 82 && kind > 64)
1234 kind = 64;
1235 break;
1236 case 224:
1237 if (curChar == 69)
1238 jjstateSet[jjnewStateCnt++] = 223;
1239 break;
1240 case 225:
1241 if (curChar == 87)
1242 jjstateSet[jjnewStateCnt++] = 224;
1243 break;
1244 case 226:
1245 if (curChar == 79)
1246 jjstateSet[jjnewStateCnt++] = 225;
1247 break;
1248 case 227:
1249 if (curChar == 71 && kind > 66)
1250 kind = 66;
1251 break;
1252 case 228:
1253 if (curChar == 78)
1254 jjstateSet[jjnewStateCnt++] = 227;
1255 break;
1256 case 229:
1257 if (curChar == 73)
1258 jjstateSet[jjnewStateCnt++] = 228;
1259 break;
1260 case 230:
1261 if (curChar == 68)
1262 jjstateSet[jjnewStateCnt++] = 229;
1263 break;
1264 case 231:
1265 if (curChar == 65)
1266 jjstateSet[jjnewStateCnt++] = 230;
1267 break;
1268 case 232:
1269 if (curChar == 69)
1270 jjstateSet[jjnewStateCnt++] = 231;
1271 break;
1272 case 233:
1273 if (curChar == 72 && kind > 69)
1274 kind = 69;
1275 break;
1276 case 234:
1277 if (curChar == 84)
1278 jjstateSet[jjnewStateCnt++] = 233;
1279 break;
1280 case 235:
1281 if (curChar == 71)
1282 jjstateSet[jjnewStateCnt++] = 234;
1283 break;
1284 case 236:
1285 if (curChar == 78)
1286 jjstateSet[jjnewStateCnt++] = 235;
1287 break;
1288 case 237:
1289 if (curChar == 69)
1290 jjstateSet[jjnewStateCnt++] = 236;
1291 break;
1292 case 238:
1293 if (curChar == 69 && kind > 70)
1294 kind = 70;
1295 break;
1296 case 239:
1297 if (curChar == 84)
1298 jjstateSet[jjnewStateCnt++] = 238;
1299 break;
1300 case 240:
1301 if (curChar == 65)
1302 jjstateSet[jjnewStateCnt++] = 239;
1303 break;
1304 case 241:
1305 if (curChar == 67)
1306 jjstateSet[jjnewStateCnt++] = 240;
1307 break;
1308 case 242:
1309 if (curChar == 79)
1310 jjstateSet[jjnewStateCnt++] = 241;
1311 break;
1312 case 243:
1313 if (curChar == 108)
1314 jjAddStates(99, 104);
1315 break;
1316 case 244:
1317 if (curChar == 116 && kind > 27)
1318 kind = 27;
1319 break;
1320 case 245:
1321 if (curChar == 102)
1322 jjstateSet[jjnewStateCnt++] = 244;
1323 break;
1324 case 246:
1325 if (curChar == 101)
1326 jjstateSet[jjnewStateCnt++] = 245;
1327 break;
1328 case 247:
1329 if (curChar == 101 && kind > 51)
1330 kind = 51;
1331 break;
1332 case 248:
1333 if (curChar == 107)
1334 jjstateSet[jjnewStateCnt++] = 247;
1335 break;
1336 case 249:
1337 if (curChar == 105)
1338 jjstateSet[jjnewStateCnt++] = 248;
1339 break;
1340 case 250:
1341 if (curChar == 114 && kind > 64)
1342 kind = 64;
1343 break;
1344 case 251:
1345 if (curChar == 101)
1346 jjstateSet[jjnewStateCnt++] = 250;
1347 break;
1348 case 252:
1349 if (curChar == 119)
1350 jjstateSet[jjnewStateCnt++] = 251;
1351 break;
1352 case 253:
1353 if (curChar == 111)
1354 jjstateSet[jjnewStateCnt++] = 252;
1355 break;
1356 case 254:
1357 if (curChar == 103 && kind > 66)
1358 kind = 66;
1359 break;
1360 case 255:
1361 if (curChar == 110)
1362 jjstateSet[jjnewStateCnt++] = 254;
1363 break;
1364 case 256:
1365 if (curChar == 105)
1366 jjstateSet[jjnewStateCnt++] = 255;
1367 break;
1368 case 257:
1369 if (curChar == 100)
1370 jjstateSet[jjnewStateCnt++] = 256;
1371 break;
1372 case 258:
1373 if (curChar == 97)
1374 jjstateSet[jjnewStateCnt++] = 257;
1375 break;
1376 case 259:
1377 if (curChar == 101)
1378 jjstateSet[jjnewStateCnt++] = 258;
1379 break;
1380 case 260:
1381 if (curChar == 104 && kind > 69)
1382 kind = 69;
1383 break;
1384 case 261:
1385 if (curChar == 116)
1386 jjstateSet[jjnewStateCnt++] = 260;
1387 break;
1388 case 262:
1389 if (curChar == 103)
1390 jjstateSet[jjnewStateCnt++] = 261;
1391 break;
1392 case 263:
1393 if (curChar == 110)
1394 jjstateSet[jjnewStateCnt++] = 262;
1395 break;
1396 case 264:
1397 if (curChar == 101)
1398 jjstateSet[jjnewStateCnt++] = 263;
1399 break;
1400 case 265:
1401 if (curChar == 101 && kind > 70)
1402 kind = 70;
1403 break;
1404 case 266:
1405 if (curChar == 116)
1406 jjstateSet[jjnewStateCnt++] = 265;
1407 break;
1408 case 267:
1409 if (curChar == 97)
1410 jjstateSet[jjnewStateCnt++] = 266;
1411 break;
1412 case 268:
1413 if (curChar == 99)
1414 jjstateSet[jjnewStateCnt++] = 267;
1415 break;
1416 case 269:
1417 if (curChar == 111)
1418 jjstateSet[jjnewStateCnt++] = 268;
1419 break;
1420 case 270:
1421 if (curChar == 73)
1422 jjAddStates(96, 98);
1423 break;
1424 case 271:
1425 if (curChar == 82 && kind > 29)
1426 kind = 29;
1427 break;
1428 case 272:
1429 if (curChar == 69)
1430 jjstateSet[jjnewStateCnt++] = 271;
1431 break;
1432 case 273:
1433 if (curChar == 78)
1434 jjstateSet[jjnewStateCnt++] = 272;
1435 break;
1436 case 274:
1437 if (curChar == 78)
1438 jjstateSet[jjnewStateCnt++] = 273;
1439 break;
1440 case 275:
1441 if (curChar == 78 && kind > 32)
1442 kind = 32;
1443 break;
1444 case 276:
1445 if (curChar == 83 && kind > 53)
1446 kind = 53;
1447 break;
1448 case 277:
1449 if (curChar == 105)
1450 jjAddStates(93, 95);
1451 break;
1452 case 278:
1453 if (curChar == 114 && kind > 29)
1454 kind = 29;
1455 break;
1456 case 279:
1457 if (curChar == 101)
1458 jjstateSet[jjnewStateCnt++] = 278;
1459 break;
1460 case 280:
1461 if (curChar == 110)
1462 jjstateSet[jjnewStateCnt++] = 279;
1463 break;
1464 case 281:
1465 if (curChar == 110)
1466 jjstateSet[jjnewStateCnt++] = 280;
1467 break;
1468 case 282:
1469 if (curChar == 110 && kind > 32)
1470 kind = 32;
1471 break;
1472 case 283:
1473 if (curChar == 115 && kind > 53)
1474 kind = 53;
1475 break;
1476 case 284:
1477 if (curChar == 65)
1478 jjAddStates(86, 92);
1479 break;
1480 case 285:
1481 if (curChar == 83 && kind > 33)
1482 kind = 33;
1483 break;
1484 case 286:
1485 if (curChar == 71 && kind > 38)
1486 kind = 38;
1487 break;
1488 case 287:
1489 if (curChar == 86)
1490 jjstateSet[jjnewStateCnt++] = 286;
1491 break;
1492 case 288:
1493 if (curChar == 68 && kind > 48)
1494 kind = 48;
1495 break;
1496 case 289:
1497 if (curChar == 78)
1498 jjstateSet[jjnewStateCnt++] = 288;
1499 break;
1500 case 290:
1501 if (curChar == 76 && kind > 58)
1502 kind = 58;
1503 break;
1504 case 291:
1505 if (curChar == 76)
1506 jjstateSet[jjnewStateCnt++] = 290;
1507 break;
1508 case 292:
1509 if (curChar == 89 && kind > 59)
1510 kind = 59;
1511 break;
1512 case 293:
1513 if (curChar == 78)
1514 jjstateSet[jjnewStateCnt++] = 292;
1515 break;
1516 case 294:
1517 if (curChar == 83 && kind > 71)
1518 kind = 71;
1519 break;
1520 case 295:
1521 if (curChar == 66)
1522 jjstateSet[jjnewStateCnt++] = 294;
1523 break;
1524 case 296:
1525 if (curChar == 67 && kind > 79)
1526 kind = 79;
1527 break;
1528 case 297:
1529 if (curChar == 83)
1530 jjstateSet[jjnewStateCnt++] = 296;
1531 break;
1532 case 298:
1533 if (curChar == 97)
1534 jjAddStates(79, 85);
1535 break;
1536 case 299:
1537 if (curChar == 115 && kind > 33)
1538 kind = 33;
1539 break;
1540 case 300:
1541 if (curChar == 103 && kind > 38)
1542 kind = 38;
1543 break;
1544 case 301:
1545 if (curChar == 118)
1546 jjstateSet[jjnewStateCnt++] = 300;
1547 break;
1548 case 302:
1549 if (curChar == 100 && kind > 48)
1550 kind = 48;
1551 break;
1552 case 303:
1553 if (curChar == 110)
1554 jjstateSet[jjnewStateCnt++] = 302;
1555 break;
1556 case 304:
1557 if (curChar == 108 && kind > 58)
1558 kind = 58;
1559 break;
1560 case 305:
1561 if (curChar == 108)
1562 jjstateSet[jjnewStateCnt++] = 304;
1563 break;
1564 case 306:
1565 if (curChar == 121 && kind > 59)
1566 kind = 59;
1567 break;
1568 case 307:
1569 if (curChar == 110)
1570 jjstateSet[jjnewStateCnt++] = 306;
1571 break;
1572 case 308:
1573 if (curChar == 115 && kind > 71)
1574 kind = 71;
1575 break;
1576 case 309:
1577 if (curChar == 98)
1578 jjstateSet[jjnewStateCnt++] = 308;
1579 break;
1580 case 310:
1581 if (curChar == 99 && kind > 79)
1582 kind = 79;
1583 break;
1584 case 311:
1585 if (curChar == 115)
1586 jjstateSet[jjnewStateCnt++] = 310;
1587 break;
1588 case 312:
1589 if (curChar == 85)
1590 jjAddStates(77, 78);
1591 break;
1592 case 313:
1593 if (curChar == 69 && kind > 34)
1594 kind = 34;
1595 break;
1596 case 314:
1597 if (curChar == 84)
1598 jjstateSet[jjnewStateCnt++] = 313;
1599 break;
1600 case 315:
1601 if (curChar == 65)
1602 jjstateSet[jjnewStateCnt++] = 314;
1603 break;
1604 case 316:
1605 if (curChar == 68)
1606 jjstateSet[jjnewStateCnt++] = 315;
1607 break;
1608 case 317:
1609 if (curChar == 80)
1610 jjstateSet[jjnewStateCnt++] = 316;
1611 break;
1612 case 318:
1613 if (curChar == 82 && kind > 65)
1614 kind = 65;
1615 break;
1616 case 319:
1617 if (curChar == 69)
1618 jjstateSet[jjnewStateCnt++] = 318;
1619 break;
1620 case 320:
1621 if (curChar == 80)
1622 jjstateSet[jjnewStateCnt++] = 319;
1623 break;
1624 case 321:
1625 if (curChar == 80)
1626 jjstateSet[jjnewStateCnt++] = 320;
1627 break;
1628 case 322:
1629 if (curChar == 117)
1630 jjAddStates(75, 76);
1631 break;
1632 case 323:
1633 if (curChar == 101 && kind > 34)
1634 kind = 34;
1635 break;
1636 case 324:
1637 if (curChar == 116)
1638 jjstateSet[jjnewStateCnt++] = 323;
1639 break;
1640 case 325:
1641 if (curChar == 97)
1642 jjstateSet[jjnewStateCnt++] = 324;
1643 break;
1644 case 326:
1645 if (curChar == 100)
1646 jjstateSet[jjnewStateCnt++] = 325;
1647 break;
1648 case 327:
1649 if (curChar == 112)
1650 jjstateSet[jjnewStateCnt++] = 326;
1651 break;
1652 case 328:
1653 if (curChar == 114 && kind > 65)
1654 kind = 65;
1655 break;
1656 case 329:
1657 if (curChar == 101)
1658 jjstateSet[jjnewStateCnt++] = 328;
1659 break;
1660 case 330:
1661 if (curChar == 112)
1662 jjstateSet[jjnewStateCnt++] = 329;
1663 break;
1664 case 331:
1665 if (curChar == 112)
1666 jjstateSet[jjnewStateCnt++] = 330;
1667 break;
1668 case 332:
1669 if (curChar == 78)
1670 jjAddStates(72, 74);
1671 break;
1672 case 333:
1673 if (curChar == 87 && kind > 37)
1674 kind = 37;
1675 break;
1676 case 334:
1677 if (curChar == 69)
1678 jjstateSet[jjnewStateCnt++] = 333;
1679 break;
1680 case 335:
1681 if (curChar == 84 && kind > 49)
1682 kind = 49;
1683 break;
1684 case 336:
1685 if (curChar == 79)
1686 jjstateSet[jjnewStateCnt++] = 335;
1687 break;
1688 case 337:
1689 if (curChar == 76 && kind > 87)
1690 kind = 87;
1691 break;
1692 case 338:
1693 if (curChar == 76)
1694 jjstateSet[jjnewStateCnt++] = 337;
1695 break;
1696 case 339:
1697 if (curChar == 85)
1698 jjstateSet[jjnewStateCnt++] = 338;
1699 break;
1700 case 340:
1701 if (curChar == 110)
1702 jjAddStates(69, 71);
1703 break;
1704 case 341:
1705 if (curChar == 119 && kind > 37)
1706 kind = 37;
1707 break;
1708 case 342:
1709 if (curChar == 101)
1710 jjstateSet[jjnewStateCnt++] = 341;
1711 break;
1712 case 343:
1713 if (curChar == 116 && kind > 49)
1714 kind = 49;
1715 break;
1716 case 344:
1717 if (curChar == 111)
1718 jjstateSet[jjnewStateCnt++] = 343;
1719 break;
1720 case 345:
1721 if (curChar == 108 && kind > 87)
1722 kind = 87;
1723 break;
1724 case 346:
1725 if (curChar == 108)
1726 jjstateSet[jjnewStateCnt++] = 345;
1727 break;
1728 case 347:
1729 if (curChar == 117)
1730 jjstateSet[jjnewStateCnt++] = 346;
1731 break;
1732 case 348:
1733 if (curChar == 77)
1734 jjAddStates(65, 68);
1735 break;
1736 case 349:
1737 if (curChar == 88 && kind > 39)
1738 kind = 39;
1739 break;
1740 case 350:
1741 if (curChar == 65)
1742 jjstateSet[jjnewStateCnt++] = 349;
1743 break;
1744 case 351:
1745 if (curChar == 78 && kind > 40)
1746 kind = 40;
1747 break;
1748 case 352:
1749 if (curChar == 73)
1750 jjstateSet[jjnewStateCnt++] = 351;
1751 break;
1752 case 353:
1753 if (curChar == 82 && kind > 55)
1754 kind = 55;
1755 break;
1756 case 354:
1757 if (curChar == 69)
1758 jjstateSet[jjnewStateCnt++] = 353;
1759 break;
1760 case 355:
1761 if (curChar == 66)
1762 jjstateSet[jjnewStateCnt++] = 354;
1763 break;
1764 case 356:
1765 if (curChar == 77)
1766 jjstateSet[jjnewStateCnt++] = 355;
1767 break;
1768 case 357:
1769 if (curChar == 69)
1770 jjstateSet[jjnewStateCnt++] = 356;
1771 break;
1772 case 358:
1773 if (curChar == 68 && kind > 73)
1774 kind = 73;
1775 break;
1776 case 359:
1777 if (curChar == 79)
1778 jjstateSet[jjnewStateCnt++] = 358;
1779 break;
1780 case 360:
1781 if (curChar == 109)
1782 jjAddStates(61, 64);
1783 break;
1784 case 361:
1785 if (curChar == 120 && kind > 39)
1786 kind = 39;
1787 break;
1788 case 362:
1789 if (curChar == 97)
1790 jjstateSet[jjnewStateCnt++] = 361;
1791 break;
1792 case 363:
1793 if (curChar == 110 && kind > 40)
1794 kind = 40;
1795 break;
1796 case 364:
1797 if (curChar == 105)
1798 jjstateSet[jjnewStateCnt++] = 363;
1799 break;
1800 case 365:
1801 if (curChar == 114 && kind > 55)
1802 kind = 55;
1803 break;
1804 case 366:
1805 if (curChar == 101)
1806 jjstateSet[jjnewStateCnt++] = 365;
1807 break;
1808 case 367:
1809 if (curChar == 98)
1810 jjstateSet[jjnewStateCnt++] = 366;
1811 break;
1812 case 368:
1813 if (curChar == 109)
1814 jjstateSet[jjnewStateCnt++] = 367;
1815 break;
1816 case 369:
1817 if (curChar == 101)
1818 jjstateSet[jjnewStateCnt++] = 368;
1819 break;
1820 case 370:
1821 if (curChar == 100 && kind > 73)
1822 kind = 73;
1823 break;
1824 case 371:
1825 if (curChar == 111)
1826 jjstateSet[jjnewStateCnt++] = 370;
1827 break;
1828 case 372:
1829 if (curChar == 67)
1830 jjAddStates(56, 60);
1831 break;
1832 case 373:
1833 if (curChar == 84 && kind > 42)
1834 kind = 42;
1835 break;
1836 case 374:
1837 if (curChar == 78)
1838 jjstateSet[jjnewStateCnt++] = 373;
1839 break;
1840 case 375:
1841 if (curChar == 85)
1842 jjstateSet[jjnewStateCnt++] = 374;
1843 break;
1844 case 376:
1845 if (curChar == 79)
1846 jjstateSet[jjnewStateCnt++] = 375;
1847 break;
1848 case 377:
1849 if (curChar == 84 && kind > 61)
1850 kind = 61;
1851 break;
1852 case 378:
1853 if (curChar == 65)
1854 jjstateSet[jjnewStateCnt++] = 377;
1855 break;
1856 case 379:
1857 if (curChar == 67)
1858 jjstateSet[jjnewStateCnt++] = 378;
1859 break;
1860 case 380:
1861 if (curChar == 78)
1862 jjstateSet[jjnewStateCnt++] = 379;
1863 break;
1864 case 381:
1865 if (curChar == 79)
1866 jjstateSet[jjnewStateCnt++] = 380;
1867 break;
1868 case 382:
1869 if (curChar == 69 && kind > 75)
1870 kind = 75;
1871 break;
1872 case 383:
1873 if (curChar == 84)
1874 jjstateSet[jjnewStateCnt++] = 382;
1875 break;
1876 case 384:
1877 if (curChar == 65)
1878 jjstateSet[jjnewStateCnt++] = 383;
1879 break;
1880 case 385:
1881 if (curChar == 68)
1882 jjstateSet[jjnewStateCnt++] = 384;
1883 break;
1884 case 386:
1885 if (curChar == 95)
1886 jjstateSet[jjnewStateCnt++] = 385;
1887 break;
1888 case 387:
1889 if (curChar == 84)
1890 jjstateSet[jjnewStateCnt++] = 386;
1891 break;
1892 case 388:
1893 if (curChar == 78)
1894 jjstateSet[jjnewStateCnt++] = 387;
1895 break;
1896 case 389:
1897 if (curChar == 69)
1898 jjstateSet[jjnewStateCnt++] = 388;
1899 break;
1900 case 390:
1901 if (curChar == 82)
1902 jjstateSet[jjnewStateCnt++] = 389;
1903 break;
1904 case 391:
1905 if (curChar == 82)
1906 jjstateSet[jjnewStateCnt++] = 390;
1907 break;
1908 case 392:
1909 if (curChar == 85)
1910 jjstateSet[jjnewStateCnt++] = 391;
1911 break;
1912 case 393:
1913 if (curChar == 69 && kind > 76)
1914 kind = 76;
1915 break;
1916 case 394:
1917 if (curChar == 77)
1918 jjstateSet[jjnewStateCnt++] = 393;
1919 break;
1920 case 395:
1921 if (curChar == 73)
1922 jjstateSet[jjnewStateCnt++] = 394;
1923 break;
1924 case 396:
1925 if (curChar == 84)
1926 jjstateSet[jjnewStateCnt++] = 395;
1927 break;
1928 case 397:
1929 if (curChar == 95)
1930 jjstateSet[jjnewStateCnt++] = 396;
1931 break;
1932 case 398:
1933 if (curChar == 84)
1934 jjstateSet[jjnewStateCnt++] = 397;
1935 break;
1936 case 399:
1937 if (curChar == 78)
1938 jjstateSet[jjnewStateCnt++] = 398;
1939 break;
1940 case 400:
1941 if (curChar == 69)
1942 jjstateSet[jjnewStateCnt++] = 399;
1943 break;
1944 case 401:
1945 if (curChar == 82)
1946 jjstateSet[jjnewStateCnt++] = 400;
1947 break;
1948 case 402:
1949 if (curChar == 82)
1950 jjstateSet[jjnewStateCnt++] = 401;
1951 break;
1952 case 403:
1953 if (curChar == 85)
1954 jjstateSet[jjnewStateCnt++] = 402;
1955 break;
1956 case 404:
1957 if (curChar == 80 && kind > 77)
1958 kind = 77;
1959 break;
1960 case 405:
1961 if (curChar == 77)
1962 jjstateSet[jjnewStateCnt++] = 404;
1963 break;
1964 case 406:
1965 if (curChar == 65)
1966 jjstateSet[jjnewStateCnt++] = 405;
1967 break;
1968 case 407:
1969 if (curChar == 84)
1970 jjstateSet[jjnewStateCnt++] = 406;
1971 break;
1972 case 408:
1973 if (curChar == 83)
1974 jjstateSet[jjnewStateCnt++] = 407;
1975 break;
1976 case 409:
1977 if (curChar == 69)
1978 jjstateSet[jjnewStateCnt++] = 408;
1979 break;
1980 case 410:
1981 if (curChar == 77)
1982 jjstateSet[jjnewStateCnt++] = 409;
1983 break;
1984 case 411:
1985 if (curChar == 73)
1986 jjstateSet[jjnewStateCnt++] = 410;
1987 break;
1988 case 412:
1989 if (curChar == 84)
1990 jjstateSet[jjnewStateCnt++] = 411;
1991 break;
1992 case 413:
1993 if (curChar == 95)
1994 jjstateSet[jjnewStateCnt++] = 412;
1995 break;
1996 case 414:
1997 if (curChar == 84)
1998 jjstateSet[jjnewStateCnt++] = 413;
1999 break;
2000 case 415:
2001 if (curChar == 78)
2002 jjstateSet[jjnewStateCnt++] = 414;
2003 break;
2004 case 416:
2005 if (curChar == 69)
2006 jjstateSet[jjnewStateCnt++] = 415;
2007 break;
2008 case 417:
2009 if (curChar == 82)
2010 jjstateSet[jjnewStateCnt++] = 416;
2011 break;
2012 case 418:
2013 if (curChar == 82)
2014 jjstateSet[jjnewStateCnt++] = 417;
2015 break;
2016 case 419:
2017 if (curChar == 85)
2018 jjstateSet[jjnewStateCnt++] = 418;
2019 break;
2020 case 420:
2021 if (curChar == 99)
2022 jjAddStates(51, 55);
2023 break;
2024 case 421:
2025 if (curChar == 116 && kind > 42)
2026 kind = 42;
2027 break;
2028 case 422:
2029 if (curChar == 110)
2030 jjstateSet[jjnewStateCnt++] = 421;
2031 break;
2032 case 423:
2033 if (curChar == 117)
2034 jjstateSet[jjnewStateCnt++] = 422;
2035 break;
2036 case 424:
2037 if (curChar == 111)
2038 jjstateSet[jjnewStateCnt++] = 423;
2039 break;
2040 case 425:
2041 if (curChar == 116 && kind > 61)
2042 kind = 61;
2043 break;
2044 case 426:
2045 if (curChar == 97)
2046 jjstateSet[jjnewStateCnt++] = 425;
2047 break;
2048 case 427:
2049 if (curChar == 99)
2050 jjstateSet[jjnewStateCnt++] = 426;
2051 break;
2052 case 428:
2053 if (curChar == 110)
2054 jjstateSet[jjnewStateCnt++] = 427;
2055 break;
2056 case 429:
2057 if (curChar == 111)
2058 jjstateSet[jjnewStateCnt++] = 428;
2059 break;
2060 case 430:
2061 if (curChar == 101 && kind > 75)
2062 kind = 75;
2063 break;
2064 case 431:
2065 if (curChar == 116)
2066 jjstateSet[jjnewStateCnt++] = 430;
2067 break;
2068 case 432:
2069 if (curChar == 97)
2070 jjstateSet[jjnewStateCnt++] = 431;
2071 break;
2072 case 433:
2073 if (curChar == 100)
2074 jjstateSet[jjnewStateCnt++] = 432;
2075 break;
2076 case 434:
2077 if (curChar == 95)
2078 jjstateSet[jjnewStateCnt++] = 433;
2079 break;
2080 case 435:
2081 if (curChar == 116)
2082 jjstateSet[jjnewStateCnt++] = 434;
2083 break;
2084 case 436:
2085 if (curChar == 110)
2086 jjstateSet[jjnewStateCnt++] = 435;
2087 break;
2088 case 437:
2089 if (curChar == 101)
2090 jjstateSet[jjnewStateCnt++] = 436;
2091 break;
2092 case 438:
2093 if (curChar == 114)
2094 jjstateSet[jjnewStateCnt++] = 437;
2095 break;
2096 case 439:
2097 if (curChar == 114)
2098 jjstateSet[jjnewStateCnt++] = 438;
2099 break;
2100 case 440:
2101 if (curChar == 117)
2102 jjstateSet[jjnewStateCnt++] = 439;
2103 break;
2104 case 441:
2105 if (curChar == 101 && kind > 76)
2106 kind = 76;
2107 break;
2108 case 442:
2109 if (curChar == 109)
2110 jjstateSet[jjnewStateCnt++] = 441;
2111 break;
2112 case 443:
2113 if (curChar == 105)
2114 jjstateSet[jjnewStateCnt++] = 442;
2115 break;
2116 case 444:
2117 if (curChar == 116)
2118 jjstateSet[jjnewStateCnt++] = 443;
2119 break;
2120 case 445:
2121 if (curChar == 95)
2122 jjstateSet[jjnewStateCnt++] = 444;
2123 break;
2124 case 446:
2125 if (curChar == 116)
2126 jjstateSet[jjnewStateCnt++] = 445;
2127 break;
2128 case 447:
2129 if (curChar == 110)
2130 jjstateSet[jjnewStateCnt++] = 446;
2131 break;
2132 case 448:
2133 if (curChar == 101)
2134 jjstateSet[jjnewStateCnt++] = 447;
2135 break;
2136 case 449:
2137 if (curChar == 114)
2138 jjstateSet[jjnewStateCnt++] = 448;
2139 break;
2140 case 450:
2141 if (curChar == 114)
2142 jjstateSet[jjnewStateCnt++] = 449;
2143 break;
2144 case 451:
2145 if (curChar == 117)
2146 jjstateSet[jjnewStateCnt++] = 450;
2147 break;
2148 case 452:
2149 if (curChar == 112 && kind > 77)
2150 kind = 77;
2151 break;
2152 case 453:
2153 if (curChar == 109)
2154 jjstateSet[jjnewStateCnt++] = 452;
2155 break;
2156 case 454:
2157 if (curChar == 97)
2158 jjstateSet[jjnewStateCnt++] = 453;
2159 break;
2160 case 455:
2161 if (curChar == 116)
2162 jjstateSet[jjnewStateCnt++] = 454;
2163 break;
2164 case 456:
2165 if (curChar == 115)
2166 jjstateSet[jjnewStateCnt++] = 455;
2167 break;
2168 case 457:
2169 if (curChar == 101)
2170 jjstateSet[jjnewStateCnt++] = 456;
2171 break;
2172 case 458:
2173 if (curChar == 109)
2174 jjstateSet[jjnewStateCnt++] = 457;
2175 break;
2176 case 459:
2177 if (curChar == 105)
2178 jjstateSet[jjnewStateCnt++] = 458;
2179 break;
2180 case 460:
2181 if (curChar == 116)
2182 jjstateSet[jjnewStateCnt++] = 459;
2183 break;
2184 case 461:
2185 if (curChar == 95)
2186 jjstateSet[jjnewStateCnt++] = 460;
2187 break;
2188 case 462:
2189 if (curChar == 116)
2190 jjstateSet[jjnewStateCnt++] = 461;
2191 break;
2192 case 463:
2193 if (curChar == 110)
2194 jjstateSet[jjnewStateCnt++] = 462;
2195 break;
2196 case 464:
2197 if (curChar == 101)
2198 jjstateSet[jjnewStateCnt++] = 463;
2199 break;
2200 case 465:
2201 if (curChar == 114)
2202 jjstateSet[jjnewStateCnt++] = 464;
2203 break;
2204 case 466:
2205 if (curChar == 114)
2206 jjstateSet[jjnewStateCnt++] = 465;
2207 break;
2208 case 467:
2209 if (curChar == 117)
2210 jjstateSet[jjnewStateCnt++] = 466;
2211 break;
2212 case 468:
2213 if (curChar == 66)
2214 jjAddStates(47, 50);
2215 break;
2216 case 469:
2217 if (curChar == 89 && kind > 45)
2218 kind = 45;
2219 break;
2220 case 470:
2221 if (curChar == 78 && kind > 50)
2222 kind = 50;
2223 break;
2224 case 471:
2225 if (curChar == 69)
2226 jjstateSet[jjnewStateCnt++] = 470;
2227 break;
2228 case 472:
2229 if (curChar == 69)
2230 jjstateSet[jjnewStateCnt++] = 471;
2231 break;
2232 case 473:
2233 if (curChar == 87)
2234 jjstateSet[jjnewStateCnt++] = 472;
2235 break;
2236 case 474:
2237 if (curChar == 84)
2238 jjstateSet[jjnewStateCnt++] = 473;
2239 break;
2240 case 475:
2241 if (curChar == 69)
2242 jjstateSet[jjnewStateCnt++] = 474;
2243 break;
2244 case 476:
2245 if (curChar == 72 && kind > 68)
2246 kind = 68;
2247 break;
2248 case 477:
2249 if (curChar == 84)
2250 jjstateSet[jjnewStateCnt++] = 476;
2251 break;
2252 case 478:
2253 if (curChar == 79)
2254 jjstateSet[jjnewStateCnt++] = 477;
2255 break;
2256 case 479:
2257 if (curChar == 72 && kind > 74)
2258 kind = 74;
2259 break;
2260 case 480:
2261 if (curChar == 84)
2262 jjstateSet[jjnewStateCnt++] = 479;
2263 break;
2264 case 481:
2265 if (curChar == 71)
2266 jjstateSet[jjnewStateCnt++] = 480;
2267 break;
2268 case 482:
2269 if (curChar == 78)
2270 jjstateSet[jjnewStateCnt++] = 481;
2271 break;
2272 case 483:
2273 if (curChar == 69)
2274 jjstateSet[jjnewStateCnt++] = 482;
2275 break;
2276 case 484:
2277 if (curChar == 76)
2278 jjstateSet[jjnewStateCnt++] = 483;
2279 break;
2280 case 485:
2281 if (curChar == 95)
2282 jjstateSet[jjnewStateCnt++] = 484;
2283 break;
2284 case 486:
2285 if (curChar == 84)
2286 jjstateSet[jjnewStateCnt++] = 485;
2287 break;
2288 case 487:
2289 if (curChar == 73)
2290 jjstateSet[jjnewStateCnt++] = 486;
2291 break;
2292 case 488:
2293 if (curChar == 98)
2294 jjAddStates(43, 46);
2295 break;
2296 case 489:
2297 if (curChar == 121 && kind > 45)
2298 kind = 45;
2299 break;
2300 case 490:
2301 if (curChar == 110 && kind > 50)
2302 kind = 50;
2303 break;
2304 case 491:
2305 if (curChar == 101)
2306 jjstateSet[jjnewStateCnt++] = 490;
2307 break;
2308 case 492:
2309 if (curChar == 101)
2310 jjstateSet[jjnewStateCnt++] = 491;
2311 break;
2312 case 493:
2313 if (curChar == 119)
2314 jjstateSet[jjnewStateCnt++] = 492;
2315 break;
2316 case 494:
2317 if (curChar == 116)
2318 jjstateSet[jjnewStateCnt++] = 493;
2319 break;
2320 case 495:
2321 if (curChar == 101)
2322 jjstateSet[jjnewStateCnt++] = 494;
2323 break;
2324 case 496:
2325 if (curChar == 104 && kind > 68)
2326 kind = 68;
2327 break;
2328 case 497:
2329 if (curChar == 116)
2330 jjstateSet[jjnewStateCnt++] = 496;
2331 break;
2332 case 498:
2333 if (curChar == 111)
2334 jjstateSet[jjnewStateCnt++] = 497;
2335 break;
2336 case 499:
2337 if (curChar == 104 && kind > 74)
2338 kind = 74;
2339 break;
2340 case 500:
2341 if (curChar == 116)
2342 jjstateSet[jjnewStateCnt++] = 499;
2343 break;
2344 case 501:
2345 if (curChar == 103)
2346 jjstateSet[jjnewStateCnt++] = 500;
2347 break;
2348 case 502:
2349 if (curChar == 110)
2350 jjstateSet[jjnewStateCnt++] = 501;
2351 break;
2352 case 503:
2353 if (curChar == 101)
2354 jjstateSet[jjnewStateCnt++] = 502;
2355 break;
2356 case 504:
2357 if (curChar == 108)
2358 jjstateSet[jjnewStateCnt++] = 503;
2359 break;
2360 case 505:
2361 if (curChar == 95)
2362 jjstateSet[jjnewStateCnt++] = 504;
2363 break;
2364 case 506:
2365 if (curChar == 116)
2366 jjstateSet[jjnewStateCnt++] = 505;
2367 break;
2368 case 507:
2369 if (curChar == 105)
2370 jjstateSet[jjnewStateCnt++] = 506;
2371 break;
2372 case 508:
2373 if (curChar == 69)
2374 jjAddStates(40, 42);
2375 break;
2376 case 509:
2377 if (curChar == 69 && kind > 52)
2378 kind = 52;
2379 break;
2380 case 510:
2381 if (curChar == 80)
2382 jjstateSet[jjnewStateCnt++] = 509;
2383 break;
2384 case 511:
2385 if (curChar == 65)
2386 jjstateSet[jjnewStateCnt++] = 510;
2387 break;
2388 case 512:
2389 if (curChar == 67)
2390 jjstateSet[jjnewStateCnt++] = 511;
2391 break;
2392 case 513:
2393 if (curChar == 83)
2394 jjstateSet[jjnewStateCnt++] = 512;
2395 break;
2396 case 514:
2397 if (curChar == 89 && kind > 54)
2398 kind = 54;
2399 break;
2400 case 515:
2401 if (curChar == 84)
2402 jjstateSet[jjnewStateCnt++] = 514;
2403 break;
2404 case 516:
2405 if (curChar == 80)
2406 jjstateSet[jjnewStateCnt++] = 515;
2407 break;
2408 case 517:
2409 if (curChar == 77)
2410 jjstateSet[jjnewStateCnt++] = 516;
2411 break;
2412 case 518:
2413 if (curChar == 83 && kind > 57)
2414 kind = 57;
2415 break;
2416 case 519:
2417 if (curChar == 84)
2418 jjstateSet[jjnewStateCnt++] = 518;
2419 break;
2420 case 520:
2421 if (curChar == 83)
2422 jjstateSet[jjnewStateCnt++] = 519;
2423 break;
2424 case 521:
2425 if (curChar == 73)
2426 jjstateSet[jjnewStateCnt++] = 520;
2427 break;
2428 case 522:
2429 if (curChar == 88)
2430 jjstateSet[jjnewStateCnt++] = 521;
2431 break;
2432 case 523:
2433 if (curChar == 101)
2434 jjAddStates(37, 39);
2435 break;
2436 case 524:
2437 if (curChar == 101 && kind > 52)
2438 kind = 52;
2439 break;
2440 case 525:
2441 if (curChar == 112)
2442 jjstateSet[jjnewStateCnt++] = 524;
2443 break;
2444 case 526:
2445 if (curChar == 97)
2446 jjstateSet[jjnewStateCnt++] = 525;
2447 break;
2448 case 527:
2449 if (curChar == 99)
2450 jjstateSet[jjnewStateCnt++] = 526;
2451 break;
2452 case 528:
2453 if (curChar == 115)
2454 jjstateSet[jjnewStateCnt++] = 527;
2455 break;
2456 case 529:
2457 if (curChar == 121 && kind > 54)
2458 kind = 54;
2459 break;
2460 case 530:
2461 if (curChar == 116)
2462 jjstateSet[jjnewStateCnt++] = 529;
2463 break;
2464 case 531:
2465 if (curChar == 112)
2466 jjstateSet[jjnewStateCnt++] = 530;
2467 break;
2468 case 532:
2469 if (curChar == 109)
2470 jjstateSet[jjnewStateCnt++] = 531;
2471 break;
2472 case 533:
2473 if (curChar == 115 && kind > 57)
2474 kind = 57;
2475 break;
2476 case 534:
2477 if (curChar == 116)
2478 jjstateSet[jjnewStateCnt++] = 533;
2479 break;
2480 case 535:
2481 if (curChar == 115)
2482 jjstateSet[jjnewStateCnt++] = 534;
2483 break;
2484 case 536:
2485 if (curChar == 105)
2486 jjstateSet[jjnewStateCnt++] = 535;
2487 break;
2488 case 537:
2489 if (curChar == 120)
2490 jjstateSet[jjnewStateCnt++] = 536;
2491 break;
2492 case 538:
2493 if (curChar == 84)
2494 jjAddStates(35, 36);
2495 break;
2496 case 539:
2497 if (curChar == 77 && kind > 63)
2498 kind = 63;
2499 break;
2500 case 540:
2501 if (curChar == 73)
2502 jjstateSet[jjnewStateCnt++] = 539;
2503 break;
2504 case 541:
2505 if (curChar == 82)
2506 jjstateSet[jjnewStateCnt++] = 540;
2507 break;
2508 case 542:
2509 if (curChar == 71 && kind > 67)
2510 kind = 67;
2511 break;
2512 case 543:
2513 if (curChar == 78)
2514 jjstateSet[jjnewStateCnt++] = 542;
2515 break;
2516 case 544:
2517 if (curChar == 73)
2518 jjstateSet[jjnewStateCnt++] = 543;
2519 break;
2520 case 545:
2521 if (curChar == 76)
2522 jjstateSet[jjnewStateCnt++] = 544;
2523 break;
2524 case 546:
2525 if (curChar == 73)
2526 jjstateSet[jjnewStateCnt++] = 545;
2527 break;
2528 case 547:
2529 if (curChar == 65)
2530 jjstateSet[jjnewStateCnt++] = 546;
2531 break;
2532 case 548:
2533 if (curChar == 82)
2534 jjstateSet[jjnewStateCnt++] = 547;
2535 break;
2536 case 549:
2537 if (curChar == 116)
2538 jjAddStates(32, 34);
2539 break;
2540 case 550:
2541 if (curChar == 109 && kind > 63)
2542 kind = 63;
2543 break;
2544 case 551:
2545 if (curChar == 105)
2546 jjstateSet[jjnewStateCnt++] = 550;
2547 break;
2548 case 552:
2549 if (curChar == 114)
2550 jjstateSet[jjnewStateCnt++] = 551;
2551 break;
2552 case 553:
2553 if (curChar == 103 && kind > 67)
2554 kind = 67;
2555 break;
2556 case 554:
2557 if (curChar == 110)
2558 jjstateSet[jjnewStateCnt++] = 553;
2559 break;
2560 case 555:
2561 if (curChar == 105)
2562 jjstateSet[jjnewStateCnt++] = 554;
2563 break;
2564 case 556:
2565 if (curChar == 108)
2566 jjstateSet[jjnewStateCnt++] = 555;
2567 break;
2568 case 557:
2569 if (curChar == 105)
2570 jjstateSet[jjnewStateCnt++] = 556;
2571 break;
2572 case 558:
2573 if (curChar == 97)
2574 jjstateSet[jjnewStateCnt++] = 557;
2575 break;
2576 case 559:
2577 if (curChar == 114)
2578 jjstateSet[jjnewStateCnt++] = 558;
2579 break;
2580 case 560:
2581 if (curChar == 117)
2582 jjCheckNAdd(148);
2583 break;
2584 case 561:
2585 if (curChar == 114)
2586 jjstateSet[jjnewStateCnt++] = 560;
2587 break;
2588 case 563:
2589 if ((0x100000001000000L & l) != 0L)
2590 jjCheckNAdd(564);
2591 break;
2592 case 564:
2593 if ((0x7e0000007eL & l) == 0L)
2594 break;
2595 if (kind > 82)
2596 kind = 82;
2597 jjCheckNAddTwoStates(564, 565);
2598 break;
2599 case 565:
2600 if ((0x100000001000L & l) != 0L && kind > 82)
2601 kind = 82;
2602 break;
2603 default : break;
2604 }
2605 } while(i != startsAt);
2606 }
2607 else
2608 {
2609 int hiByte = (int)(curChar >> 8);
2610 int i1 = hiByte >> 6;
2611 long l1 = 1L << (hiByte & 077);
2612 int i2 = (curChar & 0xff) >> 6;
2613 long l2 = 1L << (curChar & 077);
2614 MatchLoop: do
2615 {
2616 switch(jjstateSet[--i])
2617 {
2618 case 50:
2619 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2620 jjAddStates(10, 12);
2621 break;
2622 case 59:
2623 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
2624 jjAddStates(7, 9);
2625 break;
2626 default : break;
2627 }
2628 } while(i != startsAt);
2629 }
2630 if (kind != 0x7fffffff)
2631 {
2632 jjmatchedKind = kind;
2633 jjmatchedPos = curPos;
2634 kind = 0x7fffffff;
2635 }
2636 ++curPos;
2637 if ((i = jjnewStateCnt) == (startsAt = 567 - (jjnewStateCnt = startsAt)))
2638 return curPos;
2639 try { curChar = input_stream.readChar(); }
2640 catch(java.io.IOException e) { return curPos; }
2641 }
2642}
2643static final int[] jjnextStates = {
2644 70, 71, 76, 77, 80, 81, 48, 59, 60, 62, 50, 51, 53, 44, 45, 48,
2645 50, 51, 55, 53, 59, 60, 64, 62, 72, 73, 48, 80, 81, 48, 564, 565,
2646 552, 559, 561, 541, 548, 528, 532, 537, 513, 517, 522, 489, 495, 498, 507, 469,
2647 475, 478, 487, 424, 429, 440, 451, 467, 376, 381, 392, 403, 419, 362, 364, 369,
2648 371, 350, 352, 357, 359, 342, 344, 347, 334, 336, 339, 327, 331, 317, 321, 299,
2649 301, 303, 305, 307, 309, 311, 285, 287, 289, 291, 293, 295, 297, 281, 282, 283,
2650 274, 275, 276, 246, 249, 253, 259, 264, 269, 219, 222, 226, 232, 237, 242, 205,
2651 209, 210, 211, 215, 189, 193, 194, 195, 199, 175, 180, 183, 159, 164, 167, 143,
2652 147, 151, 135, 139, 113, 115, 117, 120, 128, 131, 89, 91, 93, 96, 104, 107,
2653 46, 47, 52, 54, 56, 61, 63, 65, 74, 75, 78, 79, 82, 83,
2654};
2655private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
2656{
2657 switch(hiByte)
2658 {
2659 case 0:
2660 return ((jjbitVec2[i2] & l2) != 0L);
2661 default :
2662 if ((jjbitVec0[i1] & l1) != 0L)
2663 return true;
2664 return false;
2665 }
2666}
2667public static final String [] jjstrLiteralImages = {
2668"", null, null, null, null, null, "\50", "\51", "\173", "\175", "\133",
2669"\135", "\73", "\54", "\56", "\77", "\72", "\75", "\74", "\74\75", "\76", "\76\75",
2670"\74\76", null, null, null, null, null, null, null, null, null, null, null, null, null,
2671null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2672null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2673null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2674null, null, null, null, null, null, null, null, null, null, null, null, null, null,
2675null, "\53", "\55", "\52", "\57", };
2676public static final String [] lexStateNames = {
2677 "DEFAULT",
2678};
2679static final long[] jjtoToken = {
2680 0xffffffffffffffc1L, 0x1e7dfffffL,
2681};
2682static final long[] jjtoSkip = {
2683 0x3eL, 0x0L,
2684};
2685protected JavaCharStream input_stream;
2686private final int[] jjrounds = new int[567];
2687private final int[] jjstateSet = new int[1134];
2688protected char curChar;
2689public EJBQLParserTokenManager(JavaCharStream stream)
2690{
2691 if (JavaCharStream.staticFlag)
2692 throw new Error ("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
2693 input_stream = stream;
2694}
2695public EJBQLParserTokenManager(JavaCharStream stream, int lexState)
2696{
2697 this(stream);
2698 SwitchTo(lexState);
2699}
2700public void ReInit(JavaCharStream stream)
2701{
2702 jjmatchedPos = jjnewStateCnt = 0;
2703 curLexState = defaultLexState;
2704 input_stream = stream;
2705 ReInitRounds();
2706}
2707private final void ReInitRounds()
2708{
2709 int i;
2710 jjround = 0x80000001;
2711 for (i = 567; i-- > 0;)
2712 jjrounds[i] = 0x80000000;
2713}
2714public void ReInit(JavaCharStream stream, int lexState)
2715{
2716 ReInit(stream);
2717 SwitchTo(lexState);
2718}
2719public void SwitchTo(int lexState)
2720{
2721 if (lexState >= 1 || lexState < 0)
2722 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
2723 else
2724 curLexState = lexState;
2725}
2726
2727protected Token jjFillToken()
2728{
2729 Token t = Token.newToken(jjmatchedKind);
2730 t.kind = jjmatchedKind;
2731 String im = jjstrLiteralImages[jjmatchedKind];
2732 t.image = (im == null) ? input_stream.GetImage() : im;
2733 t.beginLine = input_stream.getBeginLine();
2734 t.beginColumn = input_stream.getBeginColumn();
2735 t.endLine = input_stream.getEndLine();
2736 t.endColumn = input_stream.getEndColumn();
2737 return t;
2738}
2739
2740int curLexState = 0;
2741int defaultLexState = 0;
2742int jjnewStateCnt;
2743int jjround;
2744int jjmatchedPos;
2745int jjmatchedKind;
2746
2747public Token getNextToken()
2748{
2749 int kind;
2750 Token specialToken = null;
2751 Token matchedToken;
2752 int curPos = 0;
2753
2754 EOFLoop :
2755 for (;;)
2756 {
2757 try
2758 {
2759 curChar = input_stream.BeginToken();
2760 }
2761 catch(java.io.IOException e)
2762 {
2763 jjmatchedKind = 0;
2764 matchedToken = jjFillToken();
2765 return matchedToken;
2766 }
2767
2768 try { input_stream.backup(0);
2769 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
2770 curChar = input_stream.BeginToken();
2771 }
2772 catch (java.io.IOException e1) { continue EOFLoop; }
2773 jjmatchedKind = 0x7fffffff;
2774 jjmatchedPos = 0;
2775 curPos = jjMoveStringLiteralDfa0_0();
2776 if (jjmatchedKind != 0x7fffffff)
2777 {
2778 if (jjmatchedPos + 1 < curPos)
2779 input_stream.backup(curPos - jjmatchedPos - 1);
2780 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2781 {
2782 matchedToken = jjFillToken();
2783 return matchedToken;
2784 }
2785 else
2786 {
2787 continue EOFLoop;
2788 }
2789 }
2790 int error_line = input_stream.getEndLine();
2791 int error_column = input_stream.getEndColumn();
2792 String error_after = null;
2793 boolean EOFSeen = false;
2794 try { input_stream.readChar(); input_stream.backup(1); }
2795 catch (java.io.IOException e1) {
2796 EOFSeen = true;
2797 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2798 if (curChar == '\n' || curChar == '\r') {
2799 error_line++;
2800 error_column = 0;
2801 }
2802 else
2803 error_column++;
2804 }
2805 if (!EOFSeen) {
2806 input_stream.backup(1);
2807 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2808 }
2809 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2810 }
2811}
2812
2813}
2814 |
Popular Tags |
Java API By Example, From Geeks To Geeks.