|
1
2 package org.ejen.ext.parsers.java_1_2;
3
4 public class JavaParserimplements JavaParserTreeConstants, JavaParserConstants {
5 protected static JJTJavaParserState jjtree = new JJTJavaParserState();
6
7
10
11
14 static final public SimpleNode CompilationUnit() throws ParseException {
15
16
17 SimpleNode jjtn000 = new SimpleNode(JJTCOMPILATIONUNIT);
18 boolean jjtc000 = true;
19
20 jjtree.openNodeScope(jjtn000);
21 try {
22 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
23 case PACKAGE:
24 PackageDeclaration();
25 break;
26
27 default:
28 jj_la1[0] = jj_gen;
29 ;
30 }
31 label_1:
32 while (true) {
33 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
34 case IMPORT:
35 ;
36 break;
37
38 default:
39 jj_la1[1] = jj_gen;
40 break label_1;
41 }
42 ImportDeclaration();
43 }
44 label_2:
45 while (true) {
46 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
47 case ABSTRACT:
48 case CLASS:
49 case FINAL:
50 case INTERFACE:
51 case PUBLIC:
52 case STRICTFP:
53 case SEMICOLON:
54 ;
55 break;
56
57 default:
58 jj_la1[2] = jj_gen;
59 break label_2;
60 }
61 TypeDeclaration();
62 }
63 jj_consume_token(0);
64 jjtree.closeNodeScope(jjtn000, true);
65 jjtc000 = false; {
66 if (true) {
67 return jjtn000;
68 }
69 }
70 } catch (Throwable  jjte000) {
71 if (jjtc000) {
72 jjtree.clearNodeScope(jjtn000);
73 jjtc000 = false;
74 } else {
75 jjtree.popNode();
76 }
77 if (jjte000 instanceof RuntimeException ) { {
78 if (true) {
79 throw (RuntimeException ) jjte000;
80 }
81 }
82 }
83 if (jjte000 instanceof ParseException) { {
84 if (true) {
85 throw (ParseException) jjte000;
86 }
87 }
88 } {
89 if (true) {
90 throw (Error ) jjte000;
91 }
92 }
93 }
94 finally {
95 if (jjtc000) {
96 jjtree.closeNodeScope(jjtn000, true);
97 }
98 }
99 throw new Error ("Missing return statement in function");
100 }
101
102 static final public void PackageDeclaration() throws ParseException {
103
104
105 SimpleNode jjtn000 = new SimpleNode(JJTPACKAGEDECLARATION);
106 boolean jjtc000 = true;
107
108 jjtree.openNodeScope(jjtn000);
109 try {
110 jj_consume_token(PACKAGE);
111 Name();
112 jj_consume_token(SEMICOLON);
113 } catch (Throwable jjte000) {
114 if (jjtc000) {
115 jjtree.clearNodeScope(jjtn000);
116 jjtc000 = false;
117 } else {
118 jjtree.popNode();
119 }
120 if (jjte000 instanceof RuntimeException ) { {
121 if (true) {
122 throw (RuntimeException ) jjte000;
123 }
124 }
125 }
126 if (jjte000 instanceof ParseException) { {
127 if (true) {
128 throw (ParseException) jjte000;
129 }
130 }
131 } {
132 if (true) {
133 throw (Error ) jjte000;
134 }
135 }
136 }
137 finally {
138 if (jjtc000) {
139 jjtree.closeNodeScope(jjtn000, true);
140 }
141 }
142 }
143
144 static final public void ImportDeclaration() throws ParseException {
145
146
147 SimpleNode jjtn000 = new SimpleNode(JJTIMPORTDECLARATION);
148 boolean jjtc000 = true;
149
150 jjtree.openNodeScope(jjtn000);
151 try {
152 jj_consume_token(IMPORT);
153 Name();
154 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
155 case DOT:
156 jj_consume_token(DOT);
157 jj_consume_token(STAR);
158 break;
159
160 default:
161 jj_la1[3] = jj_gen;
162 ;
163 }
164 jj_consume_token(SEMICOLON);
165 } catch (Throwable jjte000) {
166 if (jjtc000) {
167 jjtree.clearNodeScope(jjtn000);
168 jjtc000 = false;
169 } else {
170 jjtree.popNode();
171 }
172 if (jjte000 instanceof RuntimeException ) { {
173 if (true) {
174 throw (RuntimeException ) jjte000;
175 }
176 }
177 }
178 if (jjte000 instanceof ParseException) { {
179 if (true) {
180 throw (ParseException) jjte000;
181 }
182 }
183 } {
184 if (true) {
185 throw (Error ) jjte000;
186 }
187 }
188 }
189 finally {
190 if (jjtc000) {
191 jjtree.closeNodeScope(jjtn000, true);
192 }
193 }
194 }
195
196 static final public void TypeDeclaration() throws ParseException {
197
198
199 SimpleNode jjtn000 = new SimpleNode(JJTTYPEDECLARATION);
200 boolean jjtc000 = true;
201
202 jjtree.openNodeScope(jjtn000);
203 try {
204 if (jj_2_1(2147483647)) {
205 ClassDeclaration();
206 } else {
207 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
208 case ABSTRACT:
209 case INTERFACE:
210 case PUBLIC:
211 case STRICTFP:
212 InterfaceDeclaration();
213 break;
214
215 case SEMICOLON:
216 jj_consume_token(SEMICOLON);
217 break;
218
219 default:
220 jj_la1[4] = jj_gen;
221 jj_consume_token(-1);
222 throw new ParseException();
223 }
224 }
225 } catch (Throwable jjte000) {
226 if (jjtc000) {
227 jjtree.clearNodeScope(jjtn000);
228 jjtc000 = false;
229 } else {
230 jjtree.popNode();
231 }
232 if (jjte000 instanceof RuntimeException ) { {
233 if (true) {
234 throw (RuntimeException ) jjte000;
235 }
236 }
237 }
238 if (jjte000 instanceof ParseException) { {
239 if (true) {
240 throw (ParseException) jjte000;
241 }
242 }
243 } {
244 if (true) {
245 throw (Error ) jjte000;
246 }
247 }
248 }
249 finally {
250 if (jjtc000) {
251 jjtree.closeNodeScope(jjtn000, true);
252 }
253 }
254 }
255
256
259 static final public void ClassDeclaration() throws ParseException {
260
261
262 SimpleNode jjtn000 = new SimpleNode(JJTCLASSDECLARATION);
263 boolean jjtc000 = true;
264
265 jjtree.openNodeScope(jjtn000);
266 try {
267 label_3:
268 while (true) {
269 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
270 case ABSTRACT:
271 case FINAL:
272 case PUBLIC:
273 case STRICTFP:
274 ;
275 break;
276
277 default:
278 jj_la1[5] = jj_gen;
279 break label_3;
280 }
281 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
282 case ABSTRACT:
283 jj_consume_token(ABSTRACT);
284 break;
285
286 case FINAL:
287 jj_consume_token(FINAL);
288 break;
289
290 case PUBLIC:
291 jj_consume_token(PUBLIC);
292 break;
293
294 case STRICTFP:
295 jj_consume_token(STRICTFP);
296 break;
297
298 default:
299 jj_la1[6] = jj_gen;
300 jj_consume_token(-1);
301 throw new ParseException();
302 }
303 }
304 UnmodifiedClassDeclaration();
305 } catch (Throwable jjte000) {
306 if (jjtc000) {
307 jjtree.clearNodeScope(jjtn000);
308 jjtc000 = false;
309 } else {
310 jjtree.popNode();
311 }
312 if (jjte000 instanceof RuntimeException ) { {
313 if (true) {
314 throw (RuntimeException ) jjte000;
315 }
316 }
317 }
318 if (jjte000 instanceof ParseException) { {
319 if (true) {
320 throw (ParseException) jjte000;
321 }
322 }
323 } {
324 if (true) {
325 throw (Error ) jjte000;
326 }
327 }
328 }
329 finally {
330 if (jjtc000) {
331 jjtree.closeNodeScope(jjtn000, true);
332 }
333 }
334 }
335
336 static final public void UnmodifiedClassDeclaration() throws ParseException {
337
338
339 SimpleNode jjtn000 = new SimpleNode(JJTUNMODIFIEDCLASSDECLARATION);
340 boolean jjtc000 = true;
341
342 jjtree.openNodeScope(jjtn000);
343 try {
344 jj_consume_token(CLASS);
345 jj_consume_token(IDENTIFIER);
346 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
347 case EXTENDS:
348 jj_consume_token(EXTENDS);
349 Name();
350 break;
351
352 default:
353 jj_la1[7] = jj_gen;
354 ;
355 }
356 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
357 case IMPLEMENTS:
358 jj_consume_token(IMPLEMENTS);
359 NameList();
360 break;
361
362 default:
363 jj_la1[8] = jj_gen;
364 ;
365 }
366 ClassBody();
367 } catch (Throwable jjte000) {
368 if (jjtc000) {
369 jjtree.clearNodeScope(jjtn000);
370 jjtc000 = false;
371 } else {
372 jjtree.popNode();
373 }
374 if (jjte000 instanceof RuntimeException ) { {
375 if (true) {
376 throw (RuntimeException ) jjte000;
377 }
378 }
379 }
380 if (jjte000 instanceof ParseException) { {
381 if (true) {
382 throw (ParseException) jjte000;
383 }
384 }
385 } {
386 if (true) {
387 throw (Error ) jjte000;
388 }
389 }
390 }
391 finally {
392 if (jjtc000) {
393 jjtree.closeNodeScope(jjtn000, true);
394 }
395 }
396 }
397
398 static final public void ClassBody() throws ParseException {
399
400
401 SimpleNode jjtn000 = new SimpleNode(JJTCLASSBODY);
402 boolean jjtc000 = true;
403
404 jjtree.openNodeScope(jjtn000);
405 try {
406 jj_consume_token(LBRACE);
407 label_4:
408 while (true) {
409 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
410 case ABSTRACT:
411 case BOOLEAN:
412 case BYTE:
413 case CHAR:
414 case CLASS:
415 case DOUBLE:
416 case FINAL:
417 case FLOAT:
418 case INT:
419 case INTERFACE:
420 case LONG:
421 case NATIVE:
422 case PRIVATE:
423 case PROTECTED:
424 case PUBLIC:
425 case SHORT:
426 case STATIC:
427 case SYNCHRONIZED:
428 case TRANSIENT:
429 case VOID:
430 case VOLATILE:
431 case STRICTFP:
432 case IDENTIFIER:
433 case LBRACE:
434 ;
435 break;
436
437 default:
438 jj_la1[9] = jj_gen;
439 break label_4;
440 }
441 ClassBodyDeclaration();
442 }
443 jj_consume_token(RBRACE);
444 } catch (Throwable jjte000) {
445 if (jjtc000) {
446 jjtree.clearNodeScope(jjtn000);
447 jjtc000 = false;
448 } else {
449 jjtree.popNode();
450 }
451 if (jjte000 instanceof RuntimeException ) { {
452 if (true) {
453 throw (RuntimeException ) jjte000;
454 }
455 }
456 }
457 if (jjte000 instanceof ParseException) { {
458 if (true) {
459 throw (ParseException) jjte000;
460 }
461 }
462 } {
463 if (true) {
464 throw (Error ) jjte000;
465 }
466 }
467 }
468 finally {
469 if (jjtc000) {
470 jjtree.closeNodeScope(jjtn000, true);
471 }
472 }
473 }
474
475 static final public void NestedClassDeclaration() throws ParseException {
476
477
478 SimpleNode jjtn000 = new SimpleNode(JJTNESTEDCLASSDECLARATION);
479 boolean jjtc000 = true;
480
481 jjtree.openNodeScope(jjtn000);
482 try {
483 label_5:
484 while (true) {
485 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
486 case ABSTRACT:
487 case FINAL:
488 case PRIVATE:
489 case PROTECTED:
490 case PUBLIC:
491 case STATIC:
492 case STRICTFP:
493 ;
494 break;
495
496 default:
497 jj_la1[10] = jj_gen;
498 break label_5;
499 }
500 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
501 case STATIC:
502 jj_consume_token(STATIC);
503 break;
504
505 case ABSTRACT:
506 jj_consume_token(ABSTRACT);
507 break;
508
509 case FINAL:
510 jj_consume_token(FINAL);
511 break;
512
513 case PUBLIC:
514 jj_consume_token(PUBLIC);
515 break;
516
517 case PROTECTED:
518 jj_consume_token(PROTECTED);
519 break;
520
521 case PRIVATE:
522 jj_consume_token(PRIVATE);
523 break;
524
525 case STRICTFP:
526 jj_consume_token(STRICTFP);
527 break;
528
529 default:
530 jj_la1[11] = jj_gen;
531 jj_consume_token(-1);
532 throw new ParseException();
533 }
534 }
535 UnmodifiedClassDeclaration();
536 } catch (Throwable jjte000) {
537 if (jjtc000) {
538 jjtree.clearNodeScope(jjtn000);
539 jjtc000 = false;
540 } else {
541 jjtree.popNode();
542 }
543 if (jjte000 instanceof RuntimeException ) { {
544 if (true) {
545 throw (RuntimeException ) jjte000;
546 }
547 }
548 }
549 if (jjte000 instanceof ParseException) { {
550 if (true) {
551 throw (ParseException) jjte000;
552 }
553 }
554 } {
555 if (true) {
556 throw (Error ) jjte000;
557 }
558 }
559 }
560 finally {
561 if (jjtc000) {
562 jjtree.closeNodeScope(jjtn000, true);
563 }
564 }
565 }
566
567 static final public void ClassBodyDeclaration() throws ParseException {
568
569
570 SimpleNode jjtn000 = new SimpleNode(JJTCLASSBODYDECLARATION);
571 boolean jjtc000 = true;
572
573 jjtree.openNodeScope(jjtn000);
574 try {
575 if (jj_2_2(2)) {
576 Initializer();
577 } else if (jj_2_3(2147483647)) {
578 NestedClassDeclaration();
579 } else if (jj_2_4(2147483647)) {
580 NestedInterfaceDeclaration();
581 } else if (jj_2_5(2147483647)) {
582 ConstructorDeclaration();
583 } else if (jj_2_6(2147483647)) {
584 MethodDeclaration();
585 } else {
586 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
587 case BOOLEAN:
588 case BYTE:
589 case CHAR:
590 case DOUBLE:
591 case FINAL:
592 case FLOAT:
593 case INT:
594 case LONG:
595 case PRIVATE:
596 case PROTECTED:
597 case PUBLIC:
598 case SHORT:
599 case STATIC:
600 case TRANSIENT:
601 case VOLATILE:
602 case IDENTIFIER:
603 FieldDeclaration();
604 break;
605
606 default:
607 jj_la1[12] = jj_gen;
608 jj_consume_token(-1);
609 throw new ParseException();
610 }
611 }
612 } catch (Throwable jjte000) {
613 if (jjtc000) {
614 jjtree.clearNodeScope(jjtn000);
615 jjtc000 = false;
616 } else {
617 jjtree.popNode();
618 }
619 if (jjte000 instanceof RuntimeException ) { {
620 if (true) {
621 throw (RuntimeException ) jjte000;
622 }
623 }
624 }
625 if (jjte000 instanceof ParseException) { {
626 if (true) {
627 throw (ParseException) jjte000;
628 }
629 }
630 } {
631 if (true) {
632 throw (Error ) jjte000;
633 }
634 }
635 }
636 finally {
637 if (jjtc000) {
638 jjtree.closeNodeScope(jjtn000, true);
639 }
640 }
641 }
642
643 static final public void MethodDeclarationLookahead() throws ParseException {
645
646
647 SimpleNode jjtn000 = new SimpleNode(JJTMETHODDECLARATIONLOOKAHEAD);
648 boolean jjtc000 = true;
649
650 jjtree.openNodeScope(jjtn000);
651 try {
652 label_6:
653 while (true) {
654 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
655 case ABSTRACT:
656 case FINAL:
657 case NATIVE:
658 case PRIVATE:
659 case PROTECTED:
660 case PUBLIC:
661 case STATIC:
662 case SYNCHRONIZED:
663 case STRICTFP:
664 ;
665 break;
666
667 default:
668 jj_la1[13] = jj_gen;
669 break label_6;
670 }
671 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
672 case PUBLIC:
673 jj_consume_token(PUBLIC);
674 break;
675
676 case PROTECTED:
677 jj_consume_token(PROTECTED);
678 break;
679
680 case PRIVATE:
681 jj_consume_token(PRIVATE);
682 break;
683
684 case STATIC:
685 jj_consume_token(STATIC);
686 break;
687
688 case ABSTRACT:
689 jj_consume_token(ABSTRACT);
690 break;
691
692 case FINAL:
693 jj_consume_token(FINAL);
694 break;
695
696 case NATIVE:
697 jj_consume_token(NATIVE);
698 break;
699
700 case SYNCHRONIZED:
701 jj_consume_token(SYNCHRONIZED);
702 break;
703
704 case STRICTFP:
705 jj_consume_token(STRICTFP);
706 break;
707
708 default:
709 jj_la1[14] = jj_gen;
710 jj_consume_token(-1);
711 throw new ParseException();
712 }
713 }
714 ResultType();
715 jj_consume_token(IDENTIFIER);
716 jj_consume_token(LPAREN);
717 } catch (Throwable jjte000) {
718 if (jjtc000) {
719 jjtree.clearNodeScope(jjtn000);
720 jjtc000 = false;
721 } else {
722 jjtree.popNode();
723 }
724 if (jjte000 instanceof RuntimeException ) { {
725 if (true) {
726 throw (RuntimeException ) jjte000;
727 }
728 }
729 }
730 if (jjte000 instanceof ParseException) { {
731 if (true) {
732 throw (ParseException) jjte000;
733 }
734 }
735 } {
736 if (true) {
737 throw (Error ) jjte000;
738 }
739 }
740 }
741 finally {
742 if (jjtc000) {
743 jjtree.closeNodeScope(jjtn000, true);
744 }
745 }
746 }
747
748 static final public void InterfaceDeclaration() throws ParseException {
749
750
751 SimpleNode jjtn000 = new SimpleNode(JJTINTERFACEDECLARATION);
752 boolean jjtc000 = true;
753
754 jjtree.openNodeScope(jjtn000);
755 try {
756 label_7:
757 while (true) {
758 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
759 case ABSTRACT:
760 case PUBLIC:
761 case STRICTFP:
762 ;
763 break;
764
765 default:
766 jj_la1[15] = jj_gen;
767 break label_7;
768 }
769 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
770 case ABSTRACT:
771 jj_consume_token(ABSTRACT);
772 break;
773
774 case PUBLIC:
775 jj_consume_token(PUBLIC);
776 break;
777
778 case STRICTFP:
779 jj_consume_token(STRICTFP);
780 break;
781
782 default:
783 jj_la1[16] = jj_gen;
784 jj_consume_token(-1);
785 throw new ParseException();
786 }
787 }
788 UnmodifiedInterfaceDeclaration();
789 } catch (Throwable jjte000) {
790 if (jjtc000) {
791 jjtree.clearNodeScope(jjtn000);
792 jjtc000 = false;
793 } else {
794 jjtree.popNode();
795 }
796 if (jjte000 instanceof RuntimeException ) { {
797 if (true) {
798 throw (RuntimeException ) jjte000;
799 }
800 }
801 }
802 if (jjte000 instanceof ParseException) { {
803 if (true) {
804 throw (ParseException) jjte000;
805 }
806 }
807 } {
808 if (true) {
809 throw (Error ) jjte000;
810 }
811 }
812 }
813 finally {
814 if (jjtc000) {
815 jjtree.closeNodeScope(jjtn000, true);
816 }
817 }
818 }
819
820 static final public void NestedInterfaceDeclaration() throws ParseException {
821
822
823 SimpleNode jjtn000 = new SimpleNode(JJTNESTEDINTERFACEDECLARATION);
824 boolean jjtc000 = true;
825
826 jjtree.openNodeScope(jjtn000);
827 try {
828 label_8:
829 while (true) {
830 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
831 case ABSTRACT:
832 case FINAL:
833 case PRIVATE:
834 case PROTECTED:
835 case PUBLIC:
836 case STATIC:
837 case STRICTFP:
838 ;
839 break;
840
841 default:
842 jj_la1[17] = jj_gen;
843 break label_8;
844 }
845 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
846 case STATIC:
847 jj_consume_token(STATIC);
848 break;
849
850 case ABSTRACT:
851 jj_consume_token(ABSTRACT);
852 break;
853
854 case FINAL:
855 jj_consume_token(FINAL);
856 break;
857
858 case PUBLIC:
859 jj_consume_token(PUBLIC);
860 break;
861
862 case PROTECTED:
863 jj_consume_token(PROTECTED);
864 break;
865
866 case PRIVATE:
867 jj_consume_token(PRIVATE);
868 break;
869
870 case STRICTFP:
871 jj_consume_token(STRICTFP);
872 break;
873
874 default:
875 jj_la1[18] = jj_gen;
876 jj_consume_token(-1);
877 throw new ParseException();
878 }
879 }
880 UnmodifiedInterfaceDeclaration();
881 } catch (Throwable jjte000) {
882 if (jjtc000) {
883 jjtree.clearNodeScope(jjtn000);
884 jjtc000 = false;
885 } else {
886 jjtree.popNode();
887 }
888 if (jjte000 instanceof RuntimeException ) { {
889 if (true) {
890 throw (RuntimeException ) jjte000;
891 }
892 }
893 }
894 if (jjte000 instanceof ParseException) { {
895 if (true) {
896 throw (ParseException) jjte000;
897 }
898 }
899 } {
900 if (true) {
901 throw (Error ) jjte000;
902 }
903 }
904 }
905 finally {
906 if (jjtc000) {
907 jjtree.closeNodeScope(jjtn000, true);
908 }
909 }
910 }
911
912 static final public void UnmodifiedInterfaceDeclaration() throws ParseException {
913
914
915 SimpleNode jjtn000 = new SimpleNode(JJTUNMODIFIEDINTERFACEDECLARATION);
916 boolean jjtc000 = true;
917
918 jjtree.openNodeScope(jjtn000);
919 try {
920 jj_consume_token(INTERFACE);
921 jj_consume_token(IDENTIFIER);
922 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
923 case EXTENDS:
924 jj_consume_token(EXTENDS);
925 NameList();
926 break;
927
928 default:
929 jj_la1[19] = jj_gen;
930 ;
931 }
932 jj_consume_token(LBRACE);
933 label_9:
934 while (true) {
935 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
936 case ABSTRACT:
937 case BOOLEAN:
938 case BYTE:
939 case CHAR:
940 case CLASS:
941 case DOUBLE:
942 case FINAL:
943 case FLOAT:
944 case INT:
945 case INTERFACE:
946 case LONG:
947 case NATIVE:
948 case PRIVATE:
949 case PROTECTED:
950 case PUBLIC:
951 case SHORT:
952 case STATIC:
953 case SYNCHRONIZED:
954 case TRANSIENT:
955 case VOID:
956 case VOLATILE:
957 case STRICTFP:
958 case IDENTIFIER:
959 ;
960 break;
961
962 default:
963 jj_la1[20] = jj_gen;
964 break label_9;
965 }
966 InterfaceMemberDeclaration();
967 }
968 jj_consume_token(RBRACE);
969 } catch (Throwable jjte000) {
970 if (jjtc000) {
971 jjtree.clearNodeScope(jjtn000);
972 jjtc000 = false;
973 } else {
974 jjtree.popNode();
975 }
976 if (jjte000 instanceof RuntimeException ) { {
977 if (true) {
978 throw (RuntimeException ) jjte000;
979 }
980 }
981 }
982 if (jjte000 instanceof ParseException) { {
983 if (true) {
984 throw (ParseException) jjte000;
985 }
986 }
987 } {
988 if (true) {
989 throw (Error ) jjte000;
990 }
991 }
992 }
993 finally {
994 if (jjtc000) {
995 jjtree.closeNodeScope(jjtn000, true);
996 }
997 }
998 }
999
1000 static final public void InterfaceMemberDeclaration() throws ParseException {
1001
1002
1003 SimpleNode jjtn000 = new SimpleNode(JJTINTERFACEMEMBERDECLARATION);
1004 boolean jjtc000 = true;
1005
1006 jjtree.openNodeScope(jjtn000);
1007 try {
1008 if (jj_2_7(2147483647)) {
1009 NestedClassDeclaration();
1010 } else if (jj_2_8(2147483647)) {
1011 NestedInterfaceDeclaration();
1012 } else if (jj_2_9(2147483647)) {
1013 MethodDeclaration();
1014 } else {
1015 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1016 case BOOLEAN:
1017 case BYTE:
1018 case CHAR:
1019 case DOUBLE:
1020 case FINAL:
1021 case FLOAT:
1022 case INT:
1023 case LONG:
1024 case PRIVATE:
1025 case PROTECTED:
1026 case PUBLIC:
1027 case SHORT:
1028 case STATIC:
1029 case TRANSIENT:
1030 case VOLATILE:
1031 case IDENTIFIER:
1032 FieldDeclaration();
1033 break;
1034
1035 default:
1036 jj_la1[21] = jj_gen;
1037 jj_consume_token(-1);
1038 throw new ParseException();
1039 }
1040 }
1041 } catch (Throwable jjte000) {
1042 if (jjtc000) {
1043 jjtree.clearNodeScope(jjtn000);
1044 jjtc000 = false;
1045 } else {
1046 jjtree.popNode();
1047 }
1048 if (jjte000 instanceof RuntimeException ) { {
1049 if (true) {
1050 throw (RuntimeException ) jjte000;
1051 }
1052 }
1053 }
1054 if (jjte000 instanceof ParseException) { {
1055 if (true) {
1056 throw (ParseException) jjte000;
1057 }
1058 }
1059 } {
1060 if (true) {
1061 throw (Error ) jjte000;
1062 }
1063 }
1064 }
1065 finally {
1066 if (jjtc000) {
1067 jjtree.closeNodeScope(jjtn000, true);
1068 }
1069 }
1070 }
1071
1072 static final public void FieldDeclaration() throws ParseException {
1073
1074
1075 SimpleNode jjtn000 = new SimpleNode(JJTFIELDDECLARATION);
1076 boolean jjtc000 = true;
1077
1078 jjtree.openNodeScope(jjtn000);
1079 try {
1080 label_10:
1081 while (true) {
1082 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1083 case FINAL:
1084 case PRIVATE:
1085 case PROTECTED:
1086 case PUBLIC:
1087 case STATIC:
1088 case TRANSIENT:
1089 case VOLATILE:
1090 ;
1091 break;
1092
1093 default:
1094 jj_la1[22] = jj_gen;
1095 break label_10;
1096 }
1097 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1098 case PUBLIC:
1099 jj_consume_token(PUBLIC);
1100 break;
1101
1102 case PROTECTED:
1103 jj_consume_token(PROTECTED);
1104 break;
1105
1106 case PRIVATE:
1107 jj_consume_token(PRIVATE);
1108 break;
1109
1110 case STATIC:
1111 jj_consume_token(STATIC);
1112 break;
1113
1114 case FINAL:
1115 jj_consume_token(FINAL);
1116 break;
1117
1118 case TRANSIENT:
1119 jj_consume_token(TRANSIENT);
1120 break;
1121
1122 case VOLATILE:
1123 jj_consume_token(VOLATILE);
1124 break;
1125
1126 default:
1127 jj_la1[23] = jj_gen;
1128 jj_consume_token(-1);
1129 throw new ParseException();
1130 }
1131 }
1132 Type();
1133 VariableDeclarator();
1134 label_11:
1135 while (true) {
1136 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1137 case COMMA:
1138 ;
1139 break;
1140
1141 default:
1142 jj_la1[24] = jj_gen;
1143 break label_11;
1144 }
1145 jj_consume_token(COMMA);
1146 VariableDeclarator();
1147 }
1148 jj_consume_token(SEMICOLON);
1149 } catch (Throwable jjte000) {
1150 if (jjtc000) {
1151 jjtree.clearNodeScope(jjtn000);
1152 jjtc000 = false;
1153 } else {
1154 jjtree.popNode();
1155 }
1156 if (jjte000 instanceof RuntimeException ) { {
1157 if (true) {
1158 throw (RuntimeException ) jjte000;
1159 }
1160 }
1161 }
1162 if (jjte000 instanceof ParseException) { {
1163 if (true) {
1164 throw (ParseException) jjte000;
1165 }
1166 }
1167 } {
1168 if (true) {
1169 throw (Error ) jjte000;
1170 }
1171 }
1172 }
1173 finally {
1174 if (jjtc000) {
1175 jjtree.closeNodeScope(jjtn000, true);
1176 }
1177 }
1178 }
1179
1180 static final public void VariableDeclarator() throws ParseException {
1181
1182
1183 SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEDECLARATOR);
1184 boolean jjtc000 = true;
1185
1186 jjtree.openNodeScope(jjtn000);
1187 try {
1188 VariableDeclaratorId();
1189 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1190 case ASSIGN:
1191 jj_consume_token(ASSIGN);
1192 VariableInitializer();
1193 break;
1194
1195 default:
1196 jj_la1[25] = jj_gen;
1197 ;
1198 }
1199 } catch (Throwable jjte000) {
1200 if (jjtc000) {
1201 jjtree.clearNodeScope(jjtn000);
1202 jjtc000 = false;
1203 } else {
1204 jjtree.popNode();
1205 }
1206 if (jjte000 instanceof RuntimeException ) { {
1207 if (true) {
1208 throw (RuntimeException ) jjte000;
1209 }
1210 }
1211 }
1212 if (jjte000 instanceof ParseException) { {
1213 if (true) {
1214 throw (ParseException) jjte000;
1215 }
1216 }
1217 } {
1218 if (true) {
1219 throw (Error ) jjte000;
1220 }
1221 }
1222 }
1223 finally {
1224 if (jjtc000) {
1225 jjtree.closeNodeScope(jjtn000, true);
1226 }
1227 }
1228 }
1229
1230 static final public void VariableDeclaratorId() throws ParseException {
1231
1232
1233 SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEDECLARATORID);
1234 boolean jjtc000 = true;
1235
1236 jjtree.openNodeScope(jjtn000);
1237 try {
1238 jj_consume_token(IDENTIFIER);
1239 label_12:
1240 while (true) {
1241 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1242 case LBRACKET:
1243 ;
1244 break;
1245
1246 default:
1247 jj_la1[26] = jj_gen;
1248 break label_12;
1249 }
1250 jj_consume_token(LBRACKET);
1251 jj_consume_token(RBRACKET);
1252 }
1253 }
1254 finally {
1255 if (jjtc000) {
1256 jjtree.closeNodeScope(jjtn000, true);
1257 }
1258 }
1259 }
1260
1261 static final public void VariableInitializer() throws ParseException {
1262
1263
1264 SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEINITIALIZER);
1265 boolean jjtc000 = true;
1266
1267 jjtree.openNodeScope(jjtn000);
1268 try {
1269 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1270 case LBRACE:
1271 ArrayInitializer();
1272 break;
1273
1274 case BOOLEAN:
1275 case BYTE:
1276 case CHAR:
1277 case DOUBLE:
1278 case FALSE:
1279 case FLOAT:
1280 case INT:
1281 case LONG:
1282 case NEW:
1283 case NULL:
1284 case SHORT:
1285 case SUPER:
1286 case THIS:
1287 case TRUE:
1288 case VOID:
1289 case INTEGER_LITERAL:
1290 case FLOATING_POINT_LITERAL:
1291 case CHARACTER_LITERAL:
1292 case STRING_LITERAL:
1293 case IDENTIFIER:
1294 case LPAREN:
1295 case BANG:
1296 case TILDE:
1297 case INCR:
1298 case DECR:
1299 case PLUS:
1300 case MINUS:
1301 Expression();
1302 break;
1303
1304 default:
1305 jj_la1[27] = jj_gen;
1306 jj_consume_token(-1);
1307 throw new ParseException();
1308 }
1309 } catch (Throwable jjte000) {
1310 if (jjtc000) {
1311 jjtree.clearNodeScope(jjtn000);
1312 jjtc000 = false;
1313 } else {
1314 jjtree.popNode();
1315 }
1316 if (jjte000 instanceof RuntimeException ) { {
1317 if (true) {
1318 throw (RuntimeException ) jjte000;
1319 }
1320 }
1321 }
1322 if (jjte000 instanceof ParseException) { {
1323 if (true) {
1324 throw (ParseException) jjte000;
1325 }
1326 }
1327 } {
1328 if (true) {
1329 throw (Error ) jjte000;
1330 }
1331 }
1332 }
1333 finally {
1334 if (jjtc000) {
1335 jjtree.closeNodeScope(jjtn000, true);
1336 }
1337 }
1338 }
1339
1340 static final public void ArrayInitializer() throws ParseException {
1341
1342
1343 SimpleNode jjtn000 = new SimpleNode(JJTARRAYINITIALIZER);
1344 boolean jjtc000 = true;
1345
1346 jjtree.openNodeScope(jjtn000);
1347 try {
1348 jj_consume_token(LBRACE);
1349 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1350 case BOOLEAN:
1351 case BYTE:
1352 case CHAR:
1353 case DOUBLE:
1354 case FALSE:
1355 case FLOAT:
1356 case INT:
1357 case LONG:
1358 case NEW:
1359 case NULL:
1360 case SHORT:
1361 case SUPER:
1362 case THIS:
1363 case TRUE:
1364 case VOID:
1365 case INTEGER_LITERAL:
1366 case FLOATING_POINT_LITERAL:
1367 case CHARACTER_LITERAL:
1368 case STRING_LITERAL:
1369 case IDENTIFIER:
1370 case LPAREN:
1371 case LBRACE:
1372 case BANG:
1373 case TILDE:
1374 case INCR:
1375 case DECR:
1376 case PLUS:
1377 case MINUS:
1378 VariableInitializer();
1379 label_13:
1380 while (true) {
1381 if (jj_2_10(2)) {
1382 ;
1383 } else {
1384 break label_13;
1385 }
1386 jj_consume_token(COMMA);
1387 VariableInitializer();
1388 }
1389 break;
1390
1391 default:
1392 jj_la1[28] = jj_gen;
1393 ;
1394 }
1395 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1396 case COMMA:
1397 jj_consume_token(COMMA);
1398 break;
1399
1400 default:
1401 jj_la1[29] = jj_gen;
1402 ;
1403 }
1404 jj_consume_token(RBRACE);
1405 } catch (Throwable jjte000) {
1406 if (jjtc000) {
1407 jjtree.clearNodeScope(jjtn000);
1408 jjtc000 = false;
1409 } else {
1410 jjtree.popNode();
1411 }
1412 if (jjte000 instanceof RuntimeException ) { {
1413 if (true) {
1414 throw (RuntimeException ) jjte000;
1415 }
1416 }
1417 }
1418 if (jjte000 instanceof ParseException) { {
1419 if (true) {
1420 throw (ParseException) jjte000;
1421 }
1422 }
1423 } {
1424 if (true) {
1425 throw (Error ) jjte000;
1426 }
1427 }
1428 }
1429 finally {
1430 if (jjtc000) {
1431 jjtree.closeNodeScope(jjtn000, true);
1432 }
1433 }
1434 }
1435
1436 static final public void MethodDeclaration() throws ParseException {
1437
1438
1439 SimpleNode jjtn000 = new SimpleNode(JJTMETHODDECLARATION);
1440 boolean jjtc000 = true;
1441
1442 jjtree.openNodeScope(jjtn000);
1443 try {
1444 label_14:
1445 while (true) {
1446 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1447 case ABSTRACT:
1448 case FINAL:
1449 case NATIVE:
1450 case PRIVATE:
1451 case PROTECTED:
1452 case PUBLIC:
1453 case STATIC:
1454 case SYNCHRONIZED:
1455 case STRICTFP:
1456 ;
1457 break;
1458
1459 default:
1460 jj_la1[30] = jj_gen;
1461 break label_14;
1462 }
1463 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1464 case PUBLIC:
1465 jj_consume_token(PUBLIC);
1466 break;
1467
1468 case PROTECTED:
1469 jj_consume_token(PROTECTED);
1470 break;
1471
1472 case PRIVATE:
1473 jj_consume_token(PRIVATE);
1474 break;
1475
1476 case STATIC:
1477 jj_consume_token(STATIC);
1478 break;
1479
1480 case ABSTRACT:
1481 jj_consume_token(ABSTRACT);
1482 break;
1483
1484 case FINAL:
1485 jj_consume_token(FINAL);
1486 break;
1487
1488 case NATIVE:
1489 jj_consume_token(NATIVE);
1490 break;
1491
1492 case SYNCHRONIZED:
1493 jj_consume_token(SYNCHRONIZED);
1494 break;
1495
1496 case STRICTFP:
1497 jj_consume_token(STRICTFP);
1498 break;
1499
1500 default:
1501 jj_la1[31] = jj_gen;
1502 jj_consume_token(-1);
1503 throw new ParseException();
1504 }
1505 }
1506 ResultType();
1507 MethodDeclarator();
1508 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1509 case THROWS:
1510 jj_consume_token(THROWS);
1511 NameList();
1512 break;
1513
1514 default:
1515 jj_la1[32] = jj_gen;
1516 ;
1517 }
1518 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1519 case LBRACE:
1520 Block();
1521 break;
1522
1523 case SEMICOLON:
1524 jj_consume_token(SEMICOLON);
1525 break;
1526
1527 default:
1528 jj_la1[33] = jj_gen;
1529 jj_consume_token(-1);
1530 throw new ParseException();
1531 }
1532 } catch (Throwable jjte000) {
1533 if (jjtc000) {
1534 jjtree.clearNodeScope(jjtn000);
1535 jjtc000 = false;
1536 } else {
1537 jjtree.popNode();
1538 }
1539 if (jjte000 instanceof RuntimeException ) { {
1540 if (true) {
1541 throw (RuntimeException ) jjte000;
1542 }
1543 }
1544 }
1545 if (jjte000 instanceof ParseException) { {
1546 if (true) {
1547 throw (ParseException) jjte000;
1548 }
1549 }
1550 } {
1551 if (true) {
1552 throw (Error ) jjte000;
1553 }
1554 }
1555 }
1556 finally {
1557 if (jjtc000) {
1558 jjtree.closeNodeScope(jjtn000, true);
1559 }
1560 }
1561 }
1562
1563 static final public void MethodDeclarator() throws ParseException {
1564
1565
1566 SimpleNode jjtn000 = new SimpleNode(JJTMETHODDECLARATOR);
1567 boolean jjtc000 = true;
1568
1569 jjtree.openNodeScope(jjtn000);
1570 try {
1571 jj_consume_token(IDENTIFIER);
1572 FormalParameters();
1573 label_15:
1574 while (true) {
1575 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1576 case LBRACKET:
1577 ;
1578 break;
1579
1580 default:
1581 jj_la1[34] = jj_gen;
1582 break label_15;
1583 }
1584 jj_consume_token(LBRACKET);
1585 jj_consume_token(RBRACKET);
1586 }
1587 } catch (Throwable jjte000) {
1588 if (jjtc000) {
1589 jjtree.clearNodeScope(jjtn000);
1590 jjtc000 = false;
1591 } else {
1592 jjtree.popNode();
1593 }
1594 if (jjte000 instanceof RuntimeException ) { {
1595 if (true) {
1596 throw (RuntimeException ) jjte000;
1597 }
1598 }
1599 }
1600 if (jjte000 instanceof ParseException) { {
1601 if (true) {
1602 throw (ParseException) jjte000;
1603 }
1604 }
1605 } {
1606 if (true) {
1607 throw (Error ) jjte000;
1608 }
1609 }
1610 }
1611 finally {
1612 if (jjtc000) {
1613 jjtree.closeNodeScope(jjtn000, true);
1614 }
1615 }
1616 }
1617
1618 static final public void FormalParameters() throws ParseException {
1619
1620
1621 SimpleNode jjtn000 = new SimpleNode(JJTFORMALPARAMETERS);
1622 boolean jjtc000 = true;
1623
1624 jjtree.openNodeScope(jjtn000);
1625 try {
1626 jj_consume_token(LPAREN);
1627 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1628 case BOOLEAN:
1629 case BYTE:
1630 case CHAR:
1631 case DOUBLE:
1632 case FINAL:
1633 case FLOAT:
1634 case INT:
1635 case LONG:
1636 case SHORT:
1637 case IDENTIFIER:
1638 FormalParameter();
1639 label_16:
1640 while (true) {
1641 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1642 case COMMA:
1643 ;
1644 break;
1645
1646 default:
1647 jj_la1[35] = jj_gen;
1648 break label_16;
1649 }
1650 jj_consume_token(COMMA);
1651 FormalParameter();
1652 }
1653 break;
1654
1655 default:
1656 jj_la1[36] = jj_gen;
1657 ;
1658 }
1659 jj_consume_token(RPAREN);
1660 } catch (Throwable jjte000) {
1661 if (jjtc000) {
1662 jjtree.clearNodeScope(jjtn000);
1663 jjtc000 = false;
1664 } else {
1665 jjtree.popNode();
1666 }
1667 if (jjte000 instanceof RuntimeException ) { {
1668 if (true) {
1669 throw (RuntimeException ) jjte000;
1670 }
1671 }
1672 }
1673 if (jjte000 instanceof ParseException) { {
1674 if (true) {
1675 throw (ParseException) jjte000;
1676 }
1677 }
1678 } {
1679 if (true) {
1680 throw (Error ) jjte000;
1681 }
1682 }
1683 }
1684 finally {
1685 if (jjtc000) {
1686 jjtree.closeNodeScope(jjtn000, true);
1687 }
1688 }
1689 }
1690
1691 static final public void FormalParameter() throws ParseException {
1692
1693
1694 SimpleNode jjtn000 = new SimpleNode(JJTFORMALPARAMETER);
1695 boolean jjtc000 = true;
1696
1697 jjtree.openNodeScope(jjtn000);
1698 try {
1699 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1700 case FINAL:
1701 jj_consume_token(FINAL);
1702 break;
1703
1704 default:
1705 jj_la1[37] = jj_gen;
1706 ;
1707 }
1708 Type();
1709 VariableDeclaratorId();
1710 } catch (Throwable jjte000) {
1711 if (jjtc000) {
1712 jjtree.clearNodeScope(jjtn000);
1713 jjtc000 = false;
1714 } else {
1715 jjtree.popNode();
1716 }
1717 if (jjte000 instanceof RuntimeException ) { {
1718 if (true) {
1719 throw (RuntimeException ) jjte000;
1720 }
1721 }
1722 }
1723 if (jjte000 instanceof ParseException) { {
1724 if (true) {
1725 throw (ParseException) jjte000;
1726 }
1727 }
1728 } {
1729 if (true) {
1730 throw (Error ) jjte000;
1731 }
1732 }
1733 }
1734 finally {
1735 if (jjtc000) {
1736 jjtree.closeNodeScope(jjtn000, true);
1737 }
1738 }
1739 }
1740
1741 static final public void ConstructorDeclaration() throws ParseException {
1742
1743
1744 SimpleNode jjtn000 = new SimpleNode(JJTCONSTRUCTORDECLARATION);
1745 boolean jjtc000 = true;
1746
1747 jjtree.openNodeScope(jjtn000);
1748 try {
1749 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1750 case PRIVATE:
1751 case PROTECTED:
1752 case PUBLIC:
1753 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1754 case PUBLIC:
1755 jj_consume_token(PUBLIC);
1756 break;
1757
1758 case PROTECTED:
1759 jj_consume_token(PROTECTED);
1760 break;
1761
1762 case PRIVATE:
1763 jj_consume_token(PRIVATE);
1764 break;
1765
1766 default:
1767 jj_la1[38] = jj_gen;
1768 jj_consume_token(-1);
1769 throw new ParseException();
1770 }
1771 break;
1772
1773 default:
1774 jj_la1[39] = jj_gen;
1775 ;
1776 }
1777 jj_consume_token(IDENTIFIER);
1778 FormalParameters();
1779 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1780 case THROWS:
1781 jj_consume_token(THROWS);
1782 NameList();
1783 break;
1784
1785 default:
1786 jj_la1[40] = jj_gen;
1787 ;
1788 }
1789 jj_consume_token(LBRACE);
1790 if (jj_2_11(2147483647)) {
1791 ExplicitConstructorInvocation();
1792 } else {
1793 ;
1794 }
1795 label_17:
1796 while (true) {
1797 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1798 case BOOLEAN:
1799 case BREAK:
1800 case BYTE:
1801 case CHAR:
1802 case CLASS:
1803 case CONTINUE:
1804 case DO:
1805 case DOUBLE:
1806 case FALSE:
1807 case FINAL:
1808 case FLOAT:
1809 case FOR:
1810 case IF:
1811 case INT:
1812 case INTERFACE:
1813 case LONG:
1814 case NEW:
1815 case NULL:
1816 case RETURN:
1817 case SHORT:
1818 case SUPER:
1819 case SWITCH:
1820 case SYNCHRONIZED:
1821 case THIS:
1822 case THROW:
1823 case TRUE:
1824 case TRY:
1825 case VOID:
1826 case WHILE:
1827 case INTEGER_LITERAL:
1828 case FLOATING_POINT_LITERAL:
1829 case CHARACTER_LITERAL:
1830 case STRING_LITERAL:
1831 case IDENTIFIER:
1832 case LPAREN:
1833 case LBRACE:
1834 case SEMICOLON:
1835 case INCR:
1836 case DECR:
1837 ;
1838 break;
1839
1840 default:
1841 jj_la1[41] = jj_gen;
1842 break label_17;
1843 }
1844 BlockStatement();
1845 }
1846 jj_consume_token(RBRACE);
1847 } catch (Throwable jjte000) {
1848 if (jjtc000) {
1849 jjtree.clearNodeScope(jjtn000);
1850 jjtc000 = false;
1851 } else {
1852 jjtree.popNode();
1853 }
1854 if (jjte000 instanceof RuntimeException ) { {
1855 if (true) {
1856 throw (RuntimeException ) jjte000;
1857 }
1858 }
1859 }
1860 if (jjte000 instanceof ParseException) { {
1861 if (true) {
1862 throw (ParseException) jjte000;
1863 }
1864 }
1865 } {
1866 if (true) {
1867 throw (Error ) jjte000;
1868 }
1869 }
1870 }
1871 finally {
1872 if (jjtc000) {
1873 jjtree.closeNodeScope(jjtn000, true);
1874 }
1875 }
1876 }
1877
1878 static final public void ExplicitConstructorInvocation() throws ParseException {
1879
1880
1881 SimpleNode jjtn000 = new SimpleNode(JJTEXPLICITCONSTRUCTORINVOCATION);
1882 boolean jjtc000 = true;
1883
1884 jjtree.openNodeScope(jjtn000);
1885 try {
1886 if (jj_2_13(2147483647)) {
1887 jj_consume_token(THIS);
1888 Arguments();
1889 jj_consume_token(SEMICOLON);
1890 } else {
1891 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1892 case BOOLEAN:
1893 case BYTE:
1894 case CHAR:
1895 case DOUBLE:
1896 case FALSE:
1897 case FLOAT:
1898 case INT:
1899 case LONG:
1900 case NEW:
1901 case NULL:
1902 case SHORT:
1903 case SUPER:
1904 case THIS:
1905 case TRUE:
1906 case VOID:
1907 case INTEGER_LITERAL:
1908 case FLOATING_POINT_LITERAL:
1909 case CHARACTER_LITERAL:
1910 case STRING_LITERAL:
1911 case IDENTIFIER:
1912 case LPAREN:
1913 if (jj_2_12(2)) {
1914 PrimaryExpression();
1915 jj_consume_token(DOT);
1916 } else {
1917 ;
1918 }
1919 jj_consume_token(SUPER);
1920 Arguments();
1921 jj_consume_token(SEMICOLON);
1922 break;
1923
1924 default:
1925 jj_la1[42] = jj_gen;
1926 jj_consume_token(-1);
1927 throw new ParseException();
1928 }
1929 }
1930 } catch (Throwable jjte000) {
1931 if (jjtc000) {
1932 jjtree.clearNodeScope(jjtn000);
1933 jjtc000 = false;
1934 } else {
1935 jjtree.popNode();
1936 }
1937 if (jjte000 instanceof RuntimeException ) { {
1938 if (true) {
1939 throw (RuntimeException ) jjte000;
1940 }
1941 }
1942 }
1943 if (jjte000 instanceof ParseException) { {
1944 if (true) {
1945 throw (ParseException) jjte000;
1946 }
1947 }
1948 } {
1949 if (true) {
1950 throw (Error ) jjte000;
1951 }
1952 }
1953 }
1954 finally {
1955 if (jjtc000) {
1956 jjtree.closeNodeScope(jjtn000, true);
1957 }
1958 }
1959 }
1960
1961 static final public void Initializer() throws ParseException {
1962
1963
1964 SimpleNode jjtn000 = new SimpleNode(JJTINITIALIZER);
1965 boolean jjtc000 = true;
1966
1967 jjtree.openNodeScope(jjtn000);
1968 try {
1969 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1970 case STATIC:
1971 jj_consume_token(STATIC);
1972 break;
1973
1974 default:
1975 jj_la1[43] = jj_gen;
1976 ;
1977 }
1978 Block();
1979 } catch (Throwable jjte000) {
1980 if (jjtc000) {
1981 jjtree.clearNodeScope(jjtn000);
1982 jjtc000 = false;
1983 } else {
1984 jjtree.popNode();
1985 }
1986 if (jjte000 instanceof RuntimeException ) { {
1987 if (true) {
1988 throw (RuntimeException ) jjte000;
1989 }
1990 }
1991 }
1992 if (jjte000 instanceof ParseException) { {
1993 if (true) {
1994 throw (ParseException) jjte000;
1995 }
1996 }
1997 } {
1998 if (true) {
1999 throw (Error ) jjte000;
2000 }
2001 }
2002 }
2003 finally {
2004 if (jjtc000) {
2005 jjtree.closeNodeScope(jjtn000, true);
2006 }
2007 }
2008 }
2009
2010
2013 static final public void Type() throws ParseException {
2014
2015
2016 SimpleNode jjtn000 = new SimpleNode(JJTTYPE);
2017 boolean jjtc000 = true;
2018
2019 jjtree.openNodeScope(jjtn000);
2020 try {
2021 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2022 case BOOLEAN:
2023 case BYTE:
2024 case CHAR:
2025 case DOUBLE:
2026 case FLOAT:
2027 case INT:
2028 case LONG:
2029 case SHORT:
2030 PrimitiveType();
2031 break;
2032
2033 case IDENTIFIER:
2034 Name();
2035 break;
2036
2037 default:
2038 jj_la1[44] = jj_gen;
2039 jj_consume_token(-1);
2040 throw new ParseException();
2041 }
2042 label_18:
2043 while (true) {
2044 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2045 case LBRACKET:
2046 ;
2047 break;
2048
2049 default:
2050 jj_la1[45] = jj_gen;
2051 break label_18;
2052 }
2053 jj_consume_token(LBRACKET);
2054 jj_consume_token(RBRACKET);
2055 }
2056 } catch (Throwable jjte000) {
2057 if (jjtc000) {
2058 jjtree.clearNodeScope(jjtn000);
2059 jjtc000 = false;
2060 } else {
2061 jjtree.popNode();
2062 }
2063 if (jjte000 instanceof RuntimeException ) { {
2064 if (true) {
2065 throw (RuntimeException ) jjte000;
2066 }
2067 }
2068 }
2069 if (jjte000 instanceof ParseException) { {
2070 if (true) {
2071 throw (ParseException) jjte000;
2072 }
2073 }
2074 } {
2075 if (true) {
2076 throw (Error ) jjte000;
2077 }
2078 }
2079 }
2080 finally {
2081 if (jjtc000) {
2082 jjtree.closeNodeScope(jjtn000, true);
2083 }
2084 }
2085 }
2086
2087 static final public void PrimitiveType() throws ParseException {
2088
2089
2090 SimpleNode jjtn000 = new SimpleNode(JJTPRIMITIVETYPE);
2091 boolean jjtc000 = true;
2092
2093 jjtree.openNodeScope(jjtn000);
2094 try {
2095 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2096 case BOOLEAN:
2097 jj_consume_token(BOOLEAN);
2098 break;
2099
2100 case CHAR:
2101 jj_consume_token(CHAR);
2102 break;
2103
2104 case BYTE:
2105 jj_consume_token(BYTE);
2106 break;
2107
2108 case SHORT:
2109 jj_consume_token(SHORT);
2110 break;
2111
2112 case INT:
2113 jj_consume_token(INT);
2114 break;
2115
2116 case LONG:
2117 jj_consume_token(LONG);
2118 break;
2119
2120 case FLOAT:
2121 jj_consume_token(FLOAT);
2122 break;
2123
2124 case DOUBLE:
2125 jj_consume_token(DOUBLE);
2126 break;
2127
2128 default:
2129 jj_la1[46] = jj_gen;
2130 jj_consume_token(-1);
2131 throw new ParseException();
2132 }
2133 }
2134 finally {
2135 if (jjtc000) {
2136 jjtree.closeNodeScope(jjtn000, true);
2137 }
2138 }
2139 }
2140
2141 static final public void ResultType() throws ParseException {
2142
2143
2144 SimpleNode jjtn000 = new SimpleNode(JJTRESULTTYPE);
2145 boolean jjtc000 = true;
2146
2147 jjtree.openNodeScope(jjtn000);
2148 try {
2149 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2150 case VOID:
2151 jj_consume_token(VOID);
2152 break;
2153
2154 case BOOLEAN:
2155 case BYTE:
2156 case CHAR:
2157 case DOUBLE:
2158 case FLOAT:
2159 case INT:
2160 case LONG:
2161 case SHORT:
2162 case IDENTIFIER:
2163 Type();
2164 break;
2165
2166 default:
2167 jj_la1[47] = jj_gen;
2168 jj_consume_token(-1);
2169 throw new ParseException();
2170 }
2171 } catch (Throwable jjte000) {
2172 if (jjtc000) {
2173 jjtree.clearNodeScope(jjtn000);
2174 jjtc000 = false;
2175 } else {
2176 jjtree.popNode();
2177 }
2178 if (jjte000 instanceof RuntimeException ) { {
2179 if (true) {
2180 throw (RuntimeException ) jjte000;
2181 }
2182 }
2183 }
2184 if (jjte000 instanceof ParseException) { {
2185 if (true) {
2186 throw (ParseException) jjte000;
2187 }
2188 }
2189 } {
2190 if (true) {
2191 throw (Error ) jjte000;
2192 }
2193 }
2194 }
2195 finally {
2196 if (jjtc000) {
2197 jjtree.closeNodeScope(jjtn000, true);
2198 }
2199 }
2200 }
2201
2202 static final public void Name() throws ParseException {
2203
2204
2205 SimpleNode jjtn000 = new SimpleNode(JJTNAME);
2206 boolean jjtc000 = true;
2207
2208 jjtree.openNodeScope(jjtn000);
2209 try {
2210 jj_consume_token(IDENTIFIER);
2211 label_19:
2212 while (true) {
2213 if (jj_2_14(2)) {
2214 ;
2215 } else {
2216 break label_19;
2217 }
2218 jj_consume_token(DOT);
2219 jj_consume_token(IDENTIFIER);
2220 }
2221 }
2222 finally {
2223 if (jjtc000) {
2224 jjtree.closeNodeScope(jjtn000, true);
2225 }
2226 }
2227 }
2228
2229 static final public void NameList() throws ParseException {
2230
2231
2232 SimpleNode jjtn000 = new SimpleNode(JJTNAMELIST);
2233 boolean jjtc000 = true;
2234
2235 jjtree.openNodeScope(jjtn000);
2236 try {
2237 Name();
2238 label_20:
2239 while (true) {
2240 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2241 case COMMA:
2242 ;
2243 break;
2244
2245 default:
2246 jj_la1[48] = jj_gen;
2247 break label_20;
2248 }
2249 jj_consume_token(COMMA);
2250 Name();
2251 }
2252 } catch (Throwable jjte000) {
2253 if (jjtc000) {
2254 jjtree.clearNodeScope(jjtn000);
2255 jjtc000 = false;
2256 } else {
2257 jjtree.popNode();
2258 }
2259 if (jjte000 instanceof RuntimeException ) { {
2260 if (true) {
2261 throw (RuntimeException ) jjte000;
2262 }
2263 }
2264 }
2265 if (jjte000 instanceof ParseException) { {
2266 if (true) {
2267 throw (ParseException) jjte000;
2268 }
2269 }
2270 } {
2271 if (true) {
2272 throw (Error ) jjte000;
2273 }
2274 }
2275 }
2276 finally {
2277 if (jjtc000) {
2278 jjtree.closeNodeScope(jjtn000, true);
2279 }
2280 }
2281 }
2282
2283
2286 static final public void Expression() throws ParseException {
2287
2288
2289 SimpleNode jjtn000 = new SimpleNode(JJTEXPRESSION);
2290 boolean jjtc000 = true;
2291
2292 jjtree.openNodeScope(jjtn000);
2293 try {
2294 ConditionalExpression();
2295 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2296 case ASSIGN:
2297 case PLUSASSIGN:
2298 case MINUSASSIGN:
2299 case STARASSIGN:
2300 case SLASHASSIGN:
2301 case ANDASSIGN:
2302 case ORASSIGN:
2303 case XORASSIGN:
2304 case REMASSIGN:
2305 case LSHIFTASSIGN:
2306 case RSIGNEDSHIFTASSIGN:
2307 case RUNSIGNEDSHIFTASSIGN:
2308 AssignmentOperator();
2309 Expression();
2310 break;
2311
2312 default:
2313 jj_la1[49] = jj_gen;
2314 ;
2315 }
2316 } catch (Throwable jjte000) {
2317 if (jjtc000) {
2318 jjtree.clearNodeScope(jjtn000);
2319 jjtc000 = false;
2320 } else {
2321 jjtree.popNode();
2322 }
2323 if (jjte000 instanceof RuntimeException ) { {
2324 if (true) {
2325 throw (RuntimeException ) jjte000;
2326 }
2327 }
2328 }
2329 if (jjte000 instanceof ParseException) { {
2330 if (true) {
2331 throw (ParseException) jjte000;
2332 }
2333 }
2334 } {
2335 if (true) {
2336 throw (Error ) jjte000;
2337 }
2338 }
2339 }
2340 finally {
2341 if (jjtc000) {
2342 jjtree.closeNodeScope(jjtn000, true);
2343 }
2344 }
2345 }
2346
2347 static final public void AssignmentOperator() throws ParseException {
2348
2349
2350 SimpleNode jjtn000 = new SimpleNode(JJTASSIGNMENTOPERATOR);
2351 boolean jjtc000 = true;
2352
2353 jjtree.openNodeScope(jjtn000);
2354 try {
2355 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2356 case ASSIGN:
2357 jj_consume_token(ASSIGN);
2358 break;
2359
2360 case STARASSIGN:
2361 jj_consume_token(STARASSIGN);
2362 break;
2363
2364 case SLASHASSIGN:
2365 jj_consume_token(SLASHASSIGN);
2366 break;
2367
2368 case REMASSIGN:
2369 jj_consume_token(REMASSIGN);
2370 break;
2371
2372 case PLUSASSIGN:
2373 jj_consume_token(PLUSASSIGN);
2374 break;
2375
2376 case MINUSASSIGN:
2377 jj_consume_token(MINUSASSIGN);
2378 break;
2379
2380 case LSHIFTASSIGN:
2381 jj_consume_token(LSHIFTASSIGN);
2382 break;
2383
2384 case RSIGNEDSHIFTASSIGN:
2385 jj_consume_token(RSIGNEDSHIFTASSIGN);
2386 break;
2387
2388 case RUNSIGNEDSHIFTASSIGN:
2389 jj_consume_token(RUNSIGNEDSHIFTASSIGN);
2390 break;
2391
2392 case ANDASSIGN:
2393 jj_consume_token(ANDASSIGN);
2394 break;
2395
2396 case XORASSIGN:
2397 jj_consume_token(XORASSIGN);
2398 break;
2399
2400 case ORASSIGN:
2401 jj_consume_token(ORASSIGN);
2402 break;
2403
2404 default:
2405 jj_la1[50] = jj_gen;
2406 jj_consume_token(-1);
2407 throw new ParseException();
2408 }
2409 }
2410 finally {
2411 if (jjtc000) {
2412 jjtree.closeNodeScope(jjtn000, true);
2413 }
2414 }
2415 }
2416
2417 static final public void ConditionalExpression() throws ParseException {
2418
2419
2420 SimpleNode jjtn000 = new SimpleNode(JJTCONDITIONALEXPRESSION);
2421 boolean jjtc000 = true;
2422
2423 jjtree.openNodeScope(jjtn000);
2424 try {
2425 ConditionalOrExpression();
2426 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2427 case HOOK:
2428 jj_consume_token(HOOK);
2429 Expression();
2430 jj_consume_token(COLON);
2431 ConditionalExpression();
2432 break;
2433
2434 default:
2435 jj_la1[51] = jj_gen;
2436 ;
2437 }
2438 } catch (Throwable jjte000) {
2439 if (jjtc000) {
2440 jjtree.clearNodeScope(jjtn000);
2441 jjtc000 = false;
2442 } else {
2443 jjtree.popNode();
2444 }
2445 if (jjte000 instanceof RuntimeException ) { {
2446 if (true) {
2447 throw (RuntimeException ) jjte000;
2448 }
2449 }
2450 }
2451 if (jjte000 instanceof ParseException) { {
2452 if (true) {
2453 throw (ParseException) jjte000;
2454 }
2455 }
2456 } {
2457 if (true) {
2458 throw (Error ) jjte000;
2459 }
2460 }
2461 }
2462 finally {
2463 if (jjtc000) {
2464 jjtree.closeNodeScope(jjtn000, true);
2465 }
2466 }
2467 }
2468
2469 static final public void ConditionalOrExpression() throws ParseException {
2470
2471
2472 SimpleNode jjtn000 = new SimpleNode(JJTCONDITIONALOREXPRESSION);
2473 boolean jjtc000 = true;
2474
2475 jjtree.openNodeScope(jjtn000);
2476 try {
2477 ConditionalAndExpression();
2478 label_21:
2479 while (true) {
2480 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2481 case SC_OR:
2482 ;
2483 break;
2484
2485 default:
2486 jj_la1[52] = jj_gen;
2487 break label_21;
2488 }
2489 jj_consume_token(SC_OR);
2490 ConditionalAndExpression();
2491 }
2492 } catch (Throwable jjte000) {
2493 if (jjtc000) {
2494 jjtree.clearNodeScope(jjtn000);
2495 jjtc000 = false;
2496 } else {
2497 jjtree.popNode();
2498 }
2499 if (jjte000 instanceof RuntimeException ) { {
2500 if (true) {
2501 throw (RuntimeException ) jjte000;
2502 }
2503 }
2504 }
2505 if (jjte000 instanceof ParseException) { {
2506 if (true) {
2507 throw (ParseException) jjte000;
2508 }
2509 }
2510 } {
2511 if (true) {
2512 throw (Error ) jjte000;
2513 }
2514 }
2515 }
2516 finally {
2517 if (jjtc000) {
2518 jjtree.closeNodeScope(jjtn000, true);
2519 }
2520 }
2521 }
2522
2523 static final public void ConditionalAndExpression() throws ParseException {
2524
2525
2526 SimpleNode jjtn000 = new SimpleNode(JJTCONDITIONALANDEXPRESSION);
2527 boolean jjtc000 = true;
2528
2529 jjtree.openNodeScope(jjtn000);
2530 try {
2531 InclusiveOrExpression();
2532 label_22:
2533 while (true) {
2534 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2535 case SC_AND:
2536 ;
2537 break;
2538
2539 default:
2540 jj_la1[53] = jj_gen;
2541 break label_22;
2542 }
2543 jj_consume_token(SC_AND);
2544 InclusiveOrExpression();
2545 }
2546 } catch (Throwable jjte000) {
2547 if (jjtc000) {
2548 jjtree.clearNodeScope(jjtn000);
2549 jjtc000 = false;
2550 } else {
2551 jjtree.popNode();
2552 }
2553 if (jjte000 instanceof RuntimeException ) { {
2554 if (true) {
2555 throw (RuntimeException ) jjte000;
2556 }
2557 }
2558 }
2559 if (jjte000 instanceof ParseException) { {
2560 if (true) {
2561 throw (ParseException) jjte000;
2562 }
2563 }
2564 } {
2565 if (true) {
2566 throw (Error ) jjte000;
2567 }
2568 }
2569 }
2570 finally {
2571 if (jjtc000) {
2572 jjtree.closeNodeScope(jjtn000, true);
2573 }
2574 }
2575 }
2576
2577 static final public void InclusiveOrExpression() throws ParseException {
2578
2579
2580 SimpleNode jjtn000 = new SimpleNode(JJTINCLUSIVEOREXPRESSION);
2581 boolean jjtc000 = true;
2582
2583 jjtree.openNodeScope(jjtn000);
2584 try {
2585 ExclusiveOrExpression();
2586 label_23:
2587 while (true) {
2588 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2589 case BIT_OR:
2590 ;
2591 break;
2592
2593 default:
2594 jj_la1[54] = jj_gen;
2595 break label_23;
2596 }
2597 jj_consume_token(BIT_OR);
2598 ExclusiveOrExpression();
2599 }
2600 } catch (Throwable jjte000) {
2601 if (jjtc000) {
2602 jjtree.clearNodeScope(jjtn000);
2603 jjtc000 = false;
2604 } else {
2605 jjtree.popNode();
2606 }
2607 if (jjte000 instanceof RuntimeException ) { {
2608 if (true) {
2609 throw (RuntimeException ) jjte000;
2610 }
2611 }
2612 }
2613 if (jjte000 instanceof ParseException) { {
2614 if (true) {
2615 throw (ParseException) jjte000;
2616 }
2617 }
2618 } {
2619 if (true) {
2620 throw (Error ) jjte000;
2621 }
2622 }
2623 }
2624 finally {
2625 if (jjtc000) {
2626 jjtree.closeNodeScope(jjtn000, true);
2627 }
2628 }
2629 }
2630
2631 static final public void ExclusiveOrExpression() throws ParseException {
2632
2633
2634 SimpleNode jjtn000 = new SimpleNode(JJTEXCLUSIVEOREXPRESSION);
2635 boolean jjtc000 = true;
2636
2637 jjtree.openNodeScope(jjtn000);
2638 try {
2639 AndExpression();
2640 label_24:
2641 while (true) {
2642 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2643 case XOR:
2644 ;
2645 break;
2646
2647 default:
2648 jj_la1[55] = jj_gen;
2649 break label_24;
2650 }
2651 jj_consume_token(XOR);
2652 AndExpression();
2653 }
2654 } catch (Throwable jjte000) {
2655 if (jjtc000) {
2656 jjtree.clearNodeScope(jjtn000);
2657 jjtc000 = false;
2658 } else {
2659 jjtree.popNode();
2660 }
2661 if (jjte000 instanceof RuntimeException ) { {
2662 if (true) {
2663 throw (RuntimeException ) jjte000;
2664 }
2665 }
2666 }
2667 if (jjte000 instanceof ParseException) { {
2668 if (true) {
2669 throw (ParseException) jjte000;
2670 }
2671 }
2672 } {
2673 if (true) {
2674 throw (Error ) jjte000;
2675 }
2676 }
2677 }
2678 finally {
2679 if (jjtc000) {
2680 jjtree.closeNodeScope(jjtn000, true);
2681 }
2682 }
2683 }
2684
2685 static final public void AndExpression() throws ParseException {
2686
2687
2688 SimpleNode jjtn000 = new SimpleNode(JJTANDEXPRESSION);
2689 boolean jjtc000 = true;
2690
2691 jjtree.openNodeScope(jjtn000);
2692 try {
2693 EqualityExpression();
2694 label_25:
2695 while (true) {
2696 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2697 case BIT_AND:
2698 ;
2699 break;
2700
2701 default:
2702 jj_la1[56] = jj_gen;
2703 break label_25;
2704 }
2705 jj_consume_token(BIT_AND);
2706 EqualityExpression();
2707 }
2708 } catch (Throwable jjte000) {
2709 if (jjtc000) {
2710 jjtree.clearNodeScope(jjtn000);
2711 jjtc000 = false;
2712 } else {
2713 jjtree.popNode();
2714 }
2715 if (jjte000 instanceof RuntimeException ) { {
2716 if (true) {
2717 throw (RuntimeException ) jjte000;
2718 }
2719 }
2720 }
2721 if (jjte000 instanceof ParseException) { {
2722 if (true) {
2723 throw (ParseException) jjte000;
2724 }
2725 }
2726 } {
2727 if (true) {
2728 throw (Error ) jjte000;
2729 }
2730 }
2731 }
2732 finally {
2733 if (jjtc000) {
2734 jjtree.closeNodeScope(jjtn000, true);
2735 }
2736 }
2737 }
2738
2739 static final public void EqualityExpression() throws ParseException {
2740
2741
2742 SimpleNode jjtn000 = new SimpleNode(JJTEQUALITYEXPRESSION);
2743 boolean jjtc000 = true;
2744
2745 jjtree.openNodeScope(jjtn000);
2746 try {
2747 InstanceOfExpression();
2748 label_26:
2749 while (true) {
2750 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2751 case EQ:
2752 case NE:
2753 ;
2754 break;
2755
2756 default:
2757 jj_la1[57] = jj_gen;
2758 break label_26;
2759 }
2760 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2761 case EQ:
2762 jj_consume_token(EQ);
2763 break;
2764
2765 case NE:
2766 jj_consume_token(NE);
2767 break;
2768
2769 default:
2770 jj_la1[58] = jj_gen;
2771 jj_consume_token(-1);
2772 throw new ParseException();
2773 }
2774 InstanceOfExpression();
2775 }
2776 } catch (Throwable jjte000) {
2777 if (jjtc000) {
2778 jjtree.clearNodeScope(jjtn000);
2779 jjtc000 = false;
2780 } else {
2781 jjtree.popNode();
2782 }
2783 if (jjte000 instanceof RuntimeException ) { {
2784 if (true) {
2785 throw (RuntimeException ) jjte000;
2786 }
2787 }
2788 }
2789 if (jjte000 instanceof ParseException) { {
2790 if (true) {
2791 throw (ParseException) jjte000;
2792 }
2793 }
2794 } {
2795 if (true) {
2796 throw (Error ) jjte000;
2797 }
2798 }
2799 }
2800 finally {
2801 if (jjtc000) {
2802 jjtree.closeNodeScope(jjtn000, true);
2803 }
2804 }
2805 }
2806
2807 static final public void InstanceOfExpression() throws ParseException {
2808
2809
2810 SimpleNode jjtn000 = new SimpleNode(JJTINSTANCEOFEXPRESSION);
2811 boolean jjtc000 = true;
2812
2813 jjtree.openNodeScope(jjtn000);
2814 try {
2815 RelationalExpression();
2816 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2817 case INSTANCEOF:
2818 jj_consume_token(INSTANCEOF);
2819 Type();
2820 break;
2821
2822 default:
2823 jj_la1[59] = jj_gen;
2824 ;
2825 }
2826 } catch (Throwable jjte000) {
2827 if (jjtc000) {
2828 jjtree.clearNodeScope(jjtn000);
2829 jjtc000 = false;
2830 } else {
2831 jjtree.popNode();
2832 }
2833 if (jjte000 instanceof RuntimeException ) { {
2834 if (true) {
2835 throw (RuntimeException ) jjte000;
2836 }
2837 }
2838 }
2839 if (jjte000 instanceof ParseException) { {
2840 if (true) {
2841 throw (ParseException) jjte000;
2842 }
2843 }
2844 } {
2845 if (true) {
2846 throw (Error ) jjte000;
2847 }
2848 }
2849 }
2850 finally {
2851 if (jjtc000) {
2852 jjtree.closeNodeScope(jjtn000, true);
2853 }
2854 }
2855 }
2856
2857 static final public void RelationalExpression() throws ParseException {
2858
2859
2860 SimpleNode jjtn000 = new SimpleNode(JJTRELATIONALEXPRESSION);
2861 boolean jjtc000 = true;
2862
2863 jjtree.openNodeScope(jjtn000);
2864 try {
2865 ShiftExpression();
2866 label_27:
2867 while (true) {
2868 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2869 case GT:
2870 case LT:
2871 case LE:
2872 case GE:
2873 ;
2874 break;
2875
2876 default:
2877 jj_la1[60] = jj_gen;
2878 break label_27;
2879 }
2880 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2881 case LT:
2882 jj_consume_token(LT);
2883 break;
2884
2885 case GT:
2886 jj_consume_token(GT);
2887 break;
2888
2889 case LE:
2890 jj_consume_token(LE);
2891 break;
2892
2893 case GE:
2894 jj_consume_token(GE);
2895 break;
2896
2897 default:
2898 jj_la1[61] = jj_gen;
2899 jj_consume_token(-1);
2900 throw new ParseException();
2901 }
2902 ShiftExpression();
2903 }
2904 } catch (Throwable jjte000) {
2905 if (jjtc000) {
2906 jjtree.clearNodeScope(jjtn000);
2907 jjtc000 = false;
2908 } else {
2909 jjtree.popNode();
2910 }
2911 if (jjte000 instanceof RuntimeException ) { {
2912 if (true) {
2913 throw (RuntimeException ) jjte000;
2914 }
2915 }
2916 }
2917 if (jjte000 instanceof ParseException) { {
2918 if (true) {
2919 throw (ParseException) jjte000;
2920 }
2921 }
2922 } {
2923 if (true) {
2924 throw (Error ) jjte000;
2925 }
2926 }
2927 }
2928 finally {
2929 if (jjtc000) {
2930 jjtree.closeNodeScope(jjtn000, true);
2931 }
2932 }
2933 }
2934
2935 static final public void ShiftExpression() throws ParseException {
2936
2937
2938 SimpleNode jjtn000 = new SimpleNode(JJTSHIFTEXPRESSION);
2939 boolean jjtc000 = true;
2940
2941 jjtree.openNodeScope(jjtn000);
2942 try {
2943 AdditiveExpression();
2944 label_28:
2945 while (true) {
2946 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2947 case LSHIFT:
2948 case RSIGNEDSHIFT:
2949 case RUNSIGNEDSHIFT:
2950 ;
2951 break;
2952
2953 default:
2954 jj_la1[62] = jj_gen;
2955 break label_28;
2956 }
2957 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2958 case LSHIFT:
2959 jj_consume_token(LSHIFT);
2960 break;
2961
2962 case RSIGNEDSHIFT:
2963 jj_consume_token(RSIGNEDSHIFT);
2964 break;
2965
2966 case RUNSIGNEDSHIFT:
2967 jj_consume_token(RUNSIGNEDSHIFT);
2968 break;
2969
2970 default:
2971 jj_la1[63] = jj_gen;
2972 jj_consume_token(-1);
2973 throw new ParseException();
2974 }
2975 AdditiveExpression();
2976 }
2977 } catch (Throwable jjte000) {
2978 if (jjtc000) {
2979 jjtree.clearNodeScope(jjtn000);
2980 jjtc000 = false;
2981 } else {
2982 jjtree.popNode();
2983 }
2984 if (jjte000 instanceof RuntimeException ) { {
2985 if (true) {
2986 throw (RuntimeException ) jjte000;
2987 }
2988 }
2989 }
2990 if (jjte000 instanceof ParseException) { {
2991 if (true) {
2992 throw (ParseException) jjte000;
2993 }
2994 }
2995 } {
2996 if (true) {
2997 throw (Error ) jjte000;
2998 }
2999 }
3000 }
3001 finally {
3002 if (jjtc000) {
3003 jjtree.closeNodeScope(jjtn000, true);
3004 }
3005 }
3006 }
3007
3008 static final public void AdditiveExpression() throws ParseException {
3009
3010
3011 SimpleNode jjtn000 = new SimpleNode(JJTADDITIVEEXPRESSION);
3012 boolean jjtc000 = true;
3013
3014 jjtree.openNodeScope(jjtn000);
3015 try {
3016 MultiplicativeExpression();
3017 label_29:
3018 while (true) {
3019 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3020 case PLUS:
3021 case MINUS:
3022 ;
3023 break;
3024
3025 default:
3026 jj_la1[64] = jj_gen;
3027 break label_29;
3028 }
3029 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3030 case PLUS:
3031 jj_consume_token(PLUS);
3032 break;
3033
3034 case MINUS:
3035 jj_consume_token(MINUS);
3036 break;
3037
3038 default:
3039 jj_la1[65] = jj_gen;
3040 jj_consume_token(-1);
3041 throw new ParseException();
3042 }
3043 MultiplicativeExpression();
3044 }
3045 } catch (Throwable jjte000) {
3046 if (jjtc000) {
3047 jjtree.clearNodeScope(jjtn000);
3048 jjtc000 = false;
3049 } else {
3050 jjtree.popNode();
3051 }
3052 if (jjte000 instanceof RuntimeException ) { {
3053 if (true) {
3054 throw (RuntimeException ) jjte000;
3055 }
3056 }
3057 }
3058 if (jjte000 instanceof ParseException) { {
3059 if (true) {
3060 throw (ParseException) jjte000;
3061 }
3062 }
3063 } {
3064 if (true) {
3065 throw (Error ) jjte000;
3066 }
3067 }
3068 }
3069 finally {
3070 if (jjtc000) {
3071 jjtree.closeNodeScope(jjtn000, true);
3072 }
3073 }
3074 }
3075
3076 static final public void MultiplicativeExpression() throws ParseException {
3077
3078
3079 SimpleNode jjtn000 = new SimpleNode(JJTMULTIPLICATIVEEXPRESSION);
3080 boolean jjtc000 = true;
3081
3082 jjtree.openNodeScope(jjtn000);
3083 try {
3084 UnaryExpression();
3085 label_30:
3086 while (true) {
3087 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3088 case STAR:
3089 case SLASH:
3090 case REM:
3091 ;
3092 break;
3093
3094 default:
3095 jj_la1[66] = jj_gen;
3096 break label_30;
3097 }
3098 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3099 case STAR:
3100 jj_consume_token(STAR);
3101 break;
3102
3103 case SLASH:
3104 jj_consume_token(SLASH);
3105 break;
3106
3107 case REM:
3108 jj_consume_token(REM);
3109 break;
3110
3111 default:
3112 jj_la1[67] = jj_gen;
3113 jj_consume_token(-1);
3114 throw new ParseException();
3115 }
3116 UnaryExpression();
3117 }
3118 } catch (Throwable jjte000) {
3119 if (jjtc000) {
3120 jjtree.clearNodeScope(jjtn000);
3121 jjtc000 = false;
3122 } else {
3123 jjtree.popNode();
3124 }
3125 if (jjte000 instanceof RuntimeException ) { {
3126 if (true) {
3127 throw (RuntimeException ) jjte000;
3128 }
3129 }
3130 }
3131 if (jjte000 instanceof ParseException) { {
3132 if (true) {
3133 throw (ParseException) jjte000;
3134 }
3135 }
3136 } {
3137 if (true) {
3138 throw (Error ) jjte000;
3139 }
3140 }
3141 }
3142 finally {
3143 if (jjtc000) {
3144 jjtree.closeNodeScope(jjtn000, true);
3145 }
3146 }
3147 }
3148
3149 static final public void UnaryExpression() throws ParseException {
3150
3151
3152 SimpleNode jjtn000 = new SimpleNode(JJTUNARYEXPRESSION);
3153 boolean jjtc000 = true;
3154
3155 jjtree.openNodeScope(jjtn000);
3156 try {
3157 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3158 case PLUS:
3159 case MINUS:
3160 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3161 case PLUS:
3162 jj_consume_token(PLUS);
3163 break;
3164
3165 case MINUS:
3166 jj_consume_token(MINUS);
3167 break;
3168
3169 default:
3170 jj_la1[68] = jj_gen;
3171 jj_consume_token(-1);
3172 throw new ParseException();
3173 }
3174 UnaryExpression();
3175 break;
3176
3177 case INCR:
3178 PreIncrementExpression();
3179 break;
3180
3181 case DECR:
3182 PreDecrementExpression();
3183 break;
3184
3185 case BOOLEAN:
3186 case BYTE:
3187 case CHAR:
3188 case DOUBLE:
3189 case FALSE:
3190 case FLOAT:
3191 case INT:
3192 case LONG:
3193 case NEW:
3194 case NULL:
3195 case SHORT:
3196 case SUPER:
3197 case THIS:
3198 case TRUE:
3199 case VOID:
3200 case INTEGER_LITERAL:
3201 case FLOATING_POINT_LITERAL:
3202 case CHARACTER_LITERAL:
3203 case STRING_LITERAL:
3204 case IDENTIFIER:
3205 case LPAREN:
3206 case BANG:
3207 case TILDE:
3208 UnaryExpressionNotPlusMinus();
3209 break;
3210
3211 default:
3212 jj_la1[69] = jj_gen;
3213 jj_consume_token(-1);
3214 throw new ParseException();
3215 }
3216 } catch (Throwable jjte000) {
3217 if (jjtc000) {
3218 jjtree.clearNodeScope(jjtn000);
3219 jjtc000 = false;
3220 } else {
3221 jjtree.popNode();
3222 }
3223 if (jjte000 instanceof RuntimeException ) { {
3224 if (true) {
3225 throw (RuntimeException ) jjte000;
3226 }
3227 }
3228 }
3229 if (jjte000 instanceof ParseException) { {
3230 if (true) {
3231 throw (ParseException) jjte000;
3232 }
3233 }
3234 } {
3235 if (true) {
3236 throw (Error ) jjte000;
3237 }
3238 }
3239 }
3240 finally {
3241 if (jjtc000) {
3242 jjtree.closeNodeScope(jjtn000, true);
3243 }
3244 }
3245 }
3246
3247 static final public void PreIncrementExpression() throws ParseException {
3248
3249
3250 SimpleNode jjtn000 = new SimpleNode(JJTPREINCREMENTEXPRESSION);
3251 boolean jjtc000 = true;
3252
3253 jjtree.openNodeScope(jjtn000);
3254 try {
3255 jj_consume_token(INCR);
3256 PrimaryExpression();
3257 } catch (Throwable jjte000) {
3258 if (jjtc000) {
3259 jjtree.clearNodeScope(jjtn000);
3260 jjtc000 = false;
3261 } else {
3262 jjtree.popNode();
3263 }
3264 if (jjte000 instanceof RuntimeException ) { {
3265 if (true) {
3266 throw (RuntimeException ) jjte000;
3267 }
3268 }
3269 }
3270 if (jjte000 instanceof ParseException) { {
3271 if (true) {
3272 throw (ParseException) jjte000;
3273 }
3274 }
3275 } {
3276 if (true) {
3277 throw (Error ) jjte000;
3278 }
3279 }
3280 }
3281 finally {
3282 if (jjtc000) {
3283 jjtree.closeNodeScope(jjtn000, true);
3284 }
3285 }
3286 }
3287
3288 static final public void PreDecrementExpression() throws ParseException {
3289
3290
3291 SimpleNode jjtn000 = new SimpleNode(JJTPREDECREMENTEXPRESSION);
3292 boolean jjtc000 = true;
3293
3294 jjtree.openNodeScope(jjtn000);
3295 try {
3296 jj_consume_token(DECR);
3297 PrimaryExpression();
3298 } catch (Throwable jjte000) {
3299 if (jjtc000) {
3300 jjtree.clearNodeScope(jjtn000);
3301 jjtc000 = false;
3302 } else {
3303 jjtree.popNode();
3304 }
3305 if (jjte000 instanceof RuntimeException ) { {
3306 if (true) {
3307 throw (RuntimeException ) jjte000;
3308 }
3309 }
3310 }
3311 if (jjte000 instanceof ParseException) { {
3312 if (true) {
3313 throw (ParseException) jjte000;
3314 }
3315 }
3316 } {
3317 if (true) {
3318 throw (Error ) jjte000;
3319 }
3320 }
3321 }
3322 finally {
3323 if (jjtc000) {
3324 jjtree.closeNodeScope(jjtn000, true);
3325 }
3326 }
3327 }
3328
3329 static final public void UnaryExpressionNotPlusMinus() throws ParseException {
3330
3331
3332 SimpleNode jjtn000 = new SimpleNode(JJTUNARYEXPRESSIONNOTPLUSMINUS);
3333 boolean jjtc000 = true;
3334
3335 jjtree.openNodeScope(jjtn000);
3336 try {
3337 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3338 case BANG:
3339 case TILDE:
3340 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3341 case TILDE:
3342 jj_consume_token(TILDE);
3343 break;
3344
3345 case BANG:
3346 jj_consume_token(BANG);
3347 break;
3348
3349 default:
3350 jj_la1[70] = jj_gen;
3351 jj_consume_token(-1);
3352 throw new ParseException();
3353 }
3354 UnaryExpression();
3355 break;
3356
3357 default:
3358 jj_la1[71] = jj_gen;
3359 if (jj_2_15(2147483647)) {
3360 CastExpression();
3361 } else {
3362 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3363 case BOOLEAN:
3364 case BYTE:
3365 case CHAR:
3366 case DOUBLE:
3367 case FALSE:
3368 case FLOAT:
3369 case INT:
3370 case LONG:
3371 case NEW:
3372 case NULL:
3373 case SHORT:
3374 case SUPER:
3375 case THIS:
3376 case TRUE:
3377 case VOID:
3378 case INTEGER_LITERAL:
3379 case FLOATING_POINT_LITERAL:
3380 case CHARACTER_LITERAL:
3381 case STRING_LITERAL:
3382 case IDENTIFIER:
3383 case LPAREN:
3384 PostfixExpression();
3385 break;
3386
3387 default:
3388 jj_la1[72] = jj_gen;
3389 jj_consume_token(-1);
3390 throw new ParseException();
3391 }
3392 }
3393 }
3394 } catch (Throwable jjte000) {
3395 if (jjtc000) {
3396 jjtree.clearNodeScope(jjtn000);
3397 jjtc000 = false;
3398 } else {
3399 jjtree.popNode();
3400 }
3401 if (jjte000 instanceof RuntimeException ) { {
3402 if (true) {
3403 throw (RuntimeException ) jjte000;
3404 }
3405 }
3406 }
3407 if (jjte000 instanceof ParseException) { {
3408 if (true) {
3409 throw (ParseException) jjte000;
3410 }
3411 }
3412 } {
3413 if (true) {
3414 throw (Error ) jjte000;
3415 }
3416 }
3417 }
3418 finally {
3419 if (jjtc000) {
3420 jjtree.closeNodeScope(jjtn000, true);
3421 }
3422 }
3423 }
3424
3425 static final public void CastLookahead() throws ParseException {
3429
3430
3431 SimpleNode jjtn000 = new SimpleNode(JJTCASTLOOKAHEAD);
3432 boolean jjtc000 = true;
3433
3434 jjtree.openNodeScope(jjtn000);
3435 try {
3436 if (jj_2_16(2)) {
3437 jj_consume_token(LPAREN);
3438 PrimitiveType();
3439 } else if (jj_2_17(2147483647)) {
3440 jj_consume_token(LPAREN);
3441 Name();
3442 jj_consume_token(LBRACKET);
3443 jj_consume_token(RBRACKET);
3444 } else {
3445 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3446 case LPAREN:
3447 jj_consume_token(LPAREN);
3448 Name();
3449 jj_consume_token(RPAREN);
3450 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3451 case TILDE:
3452 jj_consume_token(TILDE);
3453 break;
3454
3455 case BANG:
3456 jj_consume_token(BANG);
3457 break;
3458
3459 case LPAREN:
3460 jj_consume_token(LPAREN);
3461 break;
3462
3463 case IDENTIFIER:
3464 jj_consume_token(IDENTIFIER);
3465 break;
3466
3467 case THIS:
3468 jj_consume_token(THIS);
3469 break;
3470
3471 case SUPER:
3472 jj_consume_token(SUPER);
3473 break;
3474
3475 case NEW:
3476 jj_consume_token(NEW);
3477 break;
3478
3479 case FALSE:
3480 case NULL:
3481 case TRUE:
3482 case INTEGER_LITERAL:
3483 case FLOATING_POINT_LITERAL:
3484 case CHARACTER_LITERAL:
3485 case STRING_LITERAL:
3486 Literal();
3487 break;
3488
3489 default:
3490 jj_la1[73] = jj_gen;
3491 jj_consume_token(-1);
3492 throw new ParseException();
3493 }
3494 break;
3495
3496 default:
3497 jj_la1[74] = jj_gen;
3498 jj_consume_token(-1);
3499 throw new ParseException();
3500 }
3501 }
3502 } catch (Throwable jjte000) {
3503 if (jjtc000) {
3504 jjtree.clearNodeScope(jjtn000);
3505 jjtc000 = false;
3506 } else {
3507 jjtree.popNode();
3508 }
3509 if (jjte000 instanceof RuntimeException ) { {
3510 if (true) {
3511 throw (RuntimeException ) jjte000;
3512 }
3513 }
3514 }
3515 if (jjte000 instanceof ParseException) { {
3516 if (true) {
3517 throw (ParseException) jjte000;
3518 }
3519 }
3520 } {
3521 if (true) {
3522 throw (Error ) jjte000;
3523 }
3524 }
3525 }
3526 finally {
3527 if (jjtc000) {
3528 jjtree.closeNodeScope(jjtn000, true);
3529 }
3530 }
3531 }
3532
3533 static final public void PostfixExpression() throws ParseException {
3534
3535
3536 SimpleNode jjtn000 = new SimpleNode(JJTPOSTFIXEXPRESSION);
3537 boolean jjtc000 = true;
3538
3539 jjtree.openNodeScope(jjtn000);
3540 try {
3541 PrimaryExpression();
3542 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3543 case INCR:
3544 case DECR:
3545 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3546 case INCR:
3547 jj_consume_token(INCR);
3548 break;
3549
3550 case DECR:
3551 jj_consume_token(DECR);
3552 break;
3553
3554 default:
3555 jj_la1[75] = jj_gen;
3556 jj_consume_token(-1);
3557 throw new ParseException();
3558 }
3559 break;
3560
3561 default:
3562 jj_la1[76] = jj_gen;
3563 ;
3564 }
3565 } catch (Throwable jjte000) {
3566 if (jjtc000) {
3567 jjtree.clearNodeScope(jjtn000);
3568 jjtc000 = false;
3569 } else {
3570 jjtree.popNode();
3571 }
3572 if (jjte000 instanceof RuntimeException ) { {
3573 if (true) {
3574 throw (RuntimeException ) jjte000;
3575 }
3576 }
3577 }
3578 if (jjte000 instanceof ParseException) { {
3579 if (true) {
3580 throw (ParseException) jjte000;
3581 }
3582 }
3583 } {
3584 if (true) {
3585 throw (Error ) jjte000;
3586 }
3587 }
3588 }
3589 finally {
3590 if (jjtc000) {
3591 jjtree.closeNodeScope(jjtn000, true);
3592 }
3593 }
3594 }
3595
3596 static final public void CastExpression() throws ParseException {
3597
3598
3599 SimpleNode jjtn000 = new SimpleNode(JJTCASTEXPRESSION);
3600 boolean jjtc000 = true;
3601
3602 jjtree.openNodeScope(jjtn000);
3603 try {
3604 if (jj_2_18(2147483647)) {
3605 jj_consume_token(LPAREN);
3606 Type();
3607 jj_consume_token(RPAREN);
3608 UnaryExpression();
3609 } else {
3610 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3611 case LPAREN:
3612 jj_consume_token(LPAREN);
3613 Type();
3614 jj_consume_token(RPAREN);
3615 UnaryExpressionNotPlusMinus();
3616 break;
3617
3618 default:
3619 jj_la1[77] = jj_gen;
3620 jj_consume_token(-1);
3621 throw new ParseException();
3622 }
3623 }
3624 } catch (Throwable jjte000) {
3625 if (jjtc000) {
3626 jjtree.clearNodeScope(jjtn000);
3627 jjtc000 = false;
3628 } else {
3629 jjtree.popNode();
3630 }
3631 if (jjte000 instanceof RuntimeException ) { {
3632 if (true) {
3633 throw (RuntimeException ) jjte000;
3634 }
3635 }
3636 }
3637 if (jjte000 instanceof ParseException) { {
3638 if (true) {
3639 throw (ParseException) jjte000;
3640 }
3641 }
3642 } {
3643 if (true) {
3644 throw (Error ) jjte000;
3645 }
3646 }
3647 }
3648 finally {
3649 if (jjtc000) {
3650 jjtree.closeNodeScope(jjtn000, true);
3651 }
3652 }
3653 }
3654
3655 static final public void PrimaryExpression() throws ParseException {
3656
3657
3658 SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYEXPRESSION);
3659 boolean jjtc000 = true;
3660
3661 jjtree.openNodeScope(jjtn000);
3662 try {
3663 PrimaryPrefix();
3664 label_31:
3665 while (true) {
3666 if (jj_2_19(2)) {
3667 ;
3668 } else {
3669 break label_31;
3670 }
3671 PrimarySuffix();
3672 }
3673 } catch (Throwable jjte000) {
3674 if (jjtc000) {
3675 jjtree.clearNodeScope(jjtn000);
3676 jjtc000 = false;
3677 } else {
3678 jjtree.popNode();
3679 }
3680 if (jjte000 instanceof RuntimeException ) { {
3681 if (true) {
3682 throw (RuntimeException ) jjte000;
3683 }
3684 }
3685 }
3686 if (jjte000 instanceof ParseException) { {
3687 if (true) {
3688 throw (ParseException) jjte000;
3689 }
3690 }
3691 } {
3692 if (true) {
3693 throw (Error ) jjte000;
3694 }
3695 }
3696 }
3697 finally {
3698 if (jjtc000) {
3699 jjtree.closeNodeScope(jjtn000, true);
3700 }
3701 }
3702 }
3703
3704 static final public void PrimaryPrefix() throws ParseException {
3705
3706
3707 SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYPREFIX);
3708 boolean jjtc000 = true;
3709
3710 jjtree.openNodeScope(jjtn000);
3711 try {
3712 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3713 case FALSE:
3714 case NULL:
3715 case TRUE:
3716 case INTEGER_LITERAL:
3717 case FLOATING_POINT_LITERAL:
3718 case CHARACTER_LITERAL:
3719 case STRING_LITERAL:
3720 Literal();
3721 break;
3722
3723 case THIS:
3724 jj_consume_token(THIS);
3725 break;
3726
3727 case SUPER:
3728 jj_consume_token(SUPER);
3729 jj_consume_token(DOT);
3730 jj_consume_token(IDENTIFIER);
3731 break;
3732
3733 case LPAREN:
3734 jj_consume_token(LPAREN);
3735 Expression();
3736 jj_consume_token(RPAREN);
3737 break;
3738
3739 case NEW:
3740 AllocationExpression();
3741 break;
3742
3743 default:
3744 jj_la1[78] = jj_gen;
3745 if (jj_2_20(2147483647)) {
3746 ResultType();
3747 jj_consume_token(DOT);
3748 jj_consume_token(CLASS);
3749 } else {
3750 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3751 case IDENTIFIER:
3752 Name();
3753 break;
3754
3755 default:
3756 jj_la1[79] = jj_gen;
3757 jj_consume_token(-1);
3758 throw new ParseException();
3759 }
3760 }
3761 }
3762 } catch (Throwable jjte000) {
3763 if (jjtc000) {
3764 jjtree.clearNodeScope(jjtn000);
3765 jjtc000 = false;
3766 } else {
3767 jjtree.popNode();
3768 }
3769 if (jjte000 instanceof RuntimeException ) { {
3770 if (true) {
3771 throw (RuntimeException ) jjte000;
3772 }
3773 }
3774 }
3775 if (jjte000 instanceof ParseException) { {
3776 if (true) {
3777 throw (ParseException) jjte000;
3778 }
3779 }
3780 } {
3781 if (true) {
3782 throw (Error ) jjte000;
3783 }
3784 }
3785 }
3786 finally {
3787 if (jjtc000) {
3788 jjtree.closeNodeScope(jjtn000, true);
3789 }
3790 }
3791 }
3792
3793 static final public void PrimarySuffix() throws ParseException {
3794
3795
3796 SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYSUFFIX);
3797 boolean jjtc000 = true;
3798
3799 jjtree.openNodeScope(jjtn000);
3800 try {
3801 if (jj_2_21(2)) {
3802 jj_consume_token(DOT);
3803 jj_consume_token(THIS);
3804 } else if (jj_2_22(2)) {
3805 jj_consume_token(DOT);
3806 AllocationExpression();
3807 } else {
3808 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3809 case LBRACKET:
3810 jj_consume_token(LBRACKET);
3811 Expression();
3812 jj_consume_token(RBRACKET);
3813 break;
3814
3815 case DOT:
3816 jj_consume_token(DOT);
3817 jj_consume_token(IDENTIFIER);
3818 break;
3819
3820 case LPAREN:
3821 Arguments();
3822 break;
3823
3824 default:
3825 jj_la1[80] = jj_gen;
3826 jj_consume_token(-1);
3827 throw new ParseException();
3828 }
3829 }
3830 } catch (Throwable jjte000) {
3831 if (jjtc000) {
3832 jjtree.clearNodeScope(jjtn000);
3833 jjtc000 = false;
3834 } else {
3835 jjtree.popNode();
3836 }
3837 if (jjte000 instanceof RuntimeException ) { {
3838 if (true) {
3839 throw (RuntimeException ) jjte000;
3840 }
3841 }
3842 }
3843 if (jjte000 instanceof ParseException) { {
3844 if (true) {
3845 throw (ParseException) jjte000;
3846 }
3847 }
3848 } {
3849 if (true) {
3850 throw (Error ) jjte000;
3851 }
3852 }
3853 }
3854 finally {
3855 if (jjtc000) {
3856 jjtree.closeNodeScope(jjtn000, true);
3857 }
3858 }
3859 }
3860
3861 static final public void Literal() throws ParseException {
3862
3863
3864 SimpleNode jjtn000 = new SimpleNode(JJTLITERAL);
3865 boolean jjtc000 = true;
3866
3867 jjtree.openNodeScope(jjtn000);
3868 try {
3869 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3870 case INTEGER_LITERAL:
3871 jj_consume_token(INTEGER_LITERAL);
3872 break;
3873
3874 case FLOATING_POINT_LITERAL:
3875 jj_consume_token(FLOATING_POINT_LITERAL);
3876 break;
3877
3878 case CHARACTER_LITERAL:
3879 jj_consume_token(CHARACTER_LITERAL);
3880 break;
3881
3882 case STRING_LITERAL:
3883 jj_consume_token(STRING_LITERAL);
3884 break;
3885
3886 case FALSE:
3887 case TRUE:
3888 BooleanLiteral();
3889 break;
3890
3891 case NULL:
3892 NullLiteral();
3893 break;
3894
3895 default:
3896 jj_la1[81] = jj_gen;
3897 jj_consume_token(-1);
3898 throw new ParseException();
3899 }
3900 } catch (Throwable jjte000) {
3901 if (jjtc000) {
3902 jjtree.clearNodeScope(jjtn000);
3903 jjtc000 = false;
3904 } else {
3905 jjtree.popNode();
3906 }
3907 if (jjte000 instanceof RuntimeException ) { {
3908 if (true) {
3909 throw (RuntimeException ) jjte000;
3910 }
3911 }
3912 }
3913 if (jjte000 instanceof ParseException) { {
3914 if (true) {
3915 throw (ParseException) jjte000;
3916 }
3917 }
3918 } {
3919 if (true) {
3920 throw (Error ) jjte000;
3921 }
3922 }
3923 }
3924 finally {
3925 if (jjtc000) {
3926 jjtree.closeNodeScope(jjtn000, true);
3927 }
3928 }
3929 }
3930
3931 static final public void BooleanLiteral() throws ParseException {
3932
3933
3934 SimpleNode jjtn000 = new SimpleNode(JJTBOOLEANLITERAL);
3935 boolean jjtc000 = true;
3936
3937 jjtree.openNodeScope(jjtn000);
3938 try {
3939 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3940 case TRUE:
3941 jj_consume_token(TRUE);
3942 break;
3943
3944 case FALSE:
3945 jj_consume_token(FALSE);
3946 break;
3947
3948 default:
3949 jj_la1[82] = jj_gen;
3950 jj_consume_token(-1);
3951 throw new ParseException();
3952 }
3953 }
3954 finally {
3955 if (jjtc000) {
3956 jjtree.closeNodeScope(jjtn000, true);
3957 }
3958 }
3959 }
3960
3961 static final public void NullLiteral() throws ParseException {
3962
3963
3964 SimpleNode jjtn000 = new SimpleNode(JJTNULLLITERAL);
3965 boolean jjtc000 = true;
3966
3967 jjtree.openNodeScope(jjtn000);
3968 try {
3969 jj_consume_token(NULL);
3970 }
3971 finally {
3972 if (jjtc000) {
3973 jjtree.closeNodeScope(jjtn000, true);
3974 }
3975 }
3976 }
3977
3978 static final public void Arguments() throws ParseException {
3979
3980
3981 SimpleNode jjtn000 = new SimpleNode(JJTARGUMENTS);
3982 boolean jjtc000 = true;
3983
3984 jjtree.openNodeScope(jjtn000);
3985 try {
3986 jj_consume_token(LPAREN);
3987 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3988 case BOOLEAN:
3989 case BYTE:
3990 case CHAR:
3991 case DOUBLE:
3992 case FALSE:
3993 case FLOAT:
3994 case INT:
3995 case LONG:
3996 case NEW:
3997 case NULL:
3998 case SHORT:
3999 case SUPER:
4000 case THIS:
4001 case TRUE:
4002 case VOID:
4003 case INTEGER_LITERAL:
4004 case FLOATING_POINT_LITERAL:
4005 case CHARACTER_LITERAL:
4006 case STRING_LITERAL:
4007 case IDENTIFIER:
4008 case LPAREN:
4009 case BANG:
4010 case TILDE:
4011 case INCR:
4012 case DECR:
4013 case PLUS:
4014 case MINUS:
4015 ArgumentList();
4016 break;
4017
4018 default:
4019 jj_la1[83] = jj_gen;
4020 ;
4021 }
4022 jj_consume_token(RPAREN);
4023 } catch (Throwable jjte000) {
4024 if (jjtc000) {
4025 jjtree.clearNodeScope(jjtn000);
4026 jjtc000 = false;
4027 } else {
4028 jjtree.popNode();
4029 }
4030 if (jjte000 instanceof RuntimeException ) { {
4031 if (true) {
4032 throw (RuntimeException ) jjte000;
4033 }
4034 }
4035 }
4036 if (jjte000 instanceof ParseException) { {
4037 if (true) {
4038 throw (ParseException) jjte000;
4039 }
4040 }
4041 } {
4042 if (true) {
4043 throw (Error ) jjte000;
4044 }
4045 }
4046 }
4047 finally {
4048 if (jjtc000) {
4049 jjtree.closeNodeScope(jjtn000, true);
4050 }
4051 }
4052 }
4053
4054 static final public void ArgumentList() throws ParseException {
4055
4056
4057 SimpleNode jjtn000 = new SimpleNode(JJTARGUMENTLIST);
4058 boolean jjtc000 = true;
4059
4060 jjtree.openNodeScope(jjtn000);
4061 try {
4062 Expression();
4063 label_32:
4064 while (true) {
4065 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4066 case COMMA:
4067 ;
4068 break;
4069
4070 default:
4071 jj_la1[84] = jj_gen;
4072 break label_32;
4073 }
4074 jj_consume_token(COMMA);
4075 Expression();
4076 }
4077 } catch (Throwable jjte000) {
4078 if (jjtc000) {
4079 jjtree.clearNodeScope(jjtn000);
4080 jjtc000 = false;
4081 } else {
4082 jjtree.popNode();
4083 }
4084 if (jjte000 instanceof RuntimeException ) { {
4085 if (true) {
4086 throw (RuntimeException ) jjte000;
4087 }
4088 }
4089 }
4090 if (jjte000 instanceof ParseException) { {
4091 if (true) {
4092 throw (ParseException) jjte000;
4093 }
4094 }
4095 } {
4096 if (true) {
4097 throw (Error ) jjte000;
4098 }
4099 }
4100 }
4101 finally {
4102 if (jjtc000) {
4103 jjtree.closeNodeScope(jjtn000, true);
4104 }
4105 }
4106 }
4107
4108 static final public void AllocationExpression() throws ParseException {
4109
4110
4111 SimpleNode jjtn000 = new SimpleNode(JJTALLOCATIONEXPRESSION);
4112 boolean jjtc000 = true;
4113
4114 jjtree.openNodeScope(jjtn000);
4115 try {
4116 if (jj_2_23(2)) {
4117 jj_consume_token(NEW);
4118 PrimitiveType();
4119 ArrayDimsAndInits();
4120 } else {
4121 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4122 case NEW:
4123 jj_consume_token(NEW);
4124 Name();
4125 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4126 case LBRACKET:
4127 ArrayDimsAndInits();
4128 break;
4129
4130 case LPAREN:
4131 Arguments();
4132 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4133 case LBRACE:
4134 ClassBody();
4135 break;
4136
4137 default:
4138 jj_la1[85] = jj_gen;
4139 ;
4140 }
4141 break;
4142
4143 default:
4144 jj_la1[86] = jj_gen;
4145 jj_consume_token(-1);
4146 throw new ParseException();
4147 }
4148 break;
4149
4150 default:
4151 jj_la1[87] = jj_gen;
4152 jj_consume_token(-1);
4153 throw new ParseException();
4154 }
4155 }
4156 } catch (Throwable jjte000) {
4157 if (jjtc000) {
4158 jjtree.clearNodeScope(jjtn000);
4159 jjtc000 = false;
4160 } else {
4161 jjtree.popNode();
4162 }
4163 if (jjte000 instanceof RuntimeException ) { {
4164 if (true) {
4165 throw (RuntimeException ) jjte000;
4166 }
4167 }
4168 }
4169 if (jjte000 instanceof ParseException) { {
4170 if (true) {
4171 throw (ParseException) jjte000;
4172 }
4173 }
4174 } {
4175 if (true) {
4176 throw (Error ) jjte000;
4177 }
4178 }
4179 }
4180 finally {
4181 if (jjtc000) {
4182 jjtree.closeNodeScope(jjtn000, true);
4183 }
4184 }
4185 }
4186
4187
4191 static final public void ArrayDimsAndInits() throws ParseException {
4192
4193
4194 SimpleNode jjtn000 = new SimpleNode(JJTARRAYDIMSANDINITS);
4195 boolean jjtc000 = true;
4196
4197 jjtree.openNodeScope(jjtn000);
4198 try {
4199 if (jj_2_26(2)) {
4200 label_33:
4201 while (true) {
4202 jj_consume_token(LBRACKET);
4203 Expression();
4204 jj_consume_token(RBRACKET);
4205 if (jj_2_24(2)) {
4206 ;
4207 } else {
4208 break label_33;
4209 }
4210 }
4211 label_34:
4212 while (true) {
4213 if (jj_2_25(2)) {
4214 ;
4215 } else {
4216 break label_34;
4217 }
4218 jj_consume_token(LBRACKET);
4219 jj_consume_token(RBRACKET);
4220 }
4221 } else {
4222 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4223 case LBRACKET:
4224 label_35:
4225 while (true) {
4226 jj_consume_token(LBRACKET);
4227 jj_consume_token(RBRACKET);
4228 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4229 case LBRACKET:
4230 ;
4231 break;
4232
4233 default:
4234 jj_la1[88] = jj_gen;
4235 break label_35;
4236 }
4237 }
4238 ArrayInitializer();
4239 break;
4240
4241 default:
4242 jj_la1[89] = jj_gen;
4243 jj_consume_token(-1);
4244 throw new ParseException();
4245 }
4246 }
4247 } catch (Throwable jjte000) {
4248 if (jjtc000) {
4249 jjtree.clearNodeScope(jjtn000);
4250 jjtc000 = false;
4251 } else {
4252 jjtree.popNode();
4253 }
4254 if (jjte000 instanceof RuntimeException ) { {
4255 if (true) {
4256 throw (RuntimeException ) jjte000;
4257 }
4258 }
4259 }
4260 if (jjte000 instanceof ParseException) { {
4261 if (true) {
4262 throw (ParseException) jjte000;
4263 }
4264 }
4265 } {
4266 if (true) {
4267 throw (Error ) jjte000;
4268 }
4269 }
4270 }
4271 finally {
4272 if (jjtc000) {
4273 jjtree.closeNodeScope(jjtn000, true);
4274 }
4275 }
4276 }
4277
4278
4281 static final public void Statement() throws ParseException {
4282
4283
4284 SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENT);
4285 boolean jjtc000 = true;
4286
4287 jjtree.openNodeScope(jjtn000);
4288 try {
4289 if (jj_2_27(2)) {
4290 LabeledStatement();
4291 } else {
4292 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4293 case LBRACE:
4294 Block();
4295 break;
4296
4297 case SEMICOLON:
4298 EmptyStatement();
4299 break;
4300
4301 case BOOLEAN:
4302 case BYTE:
4303 case CHAR:
4304 case DOUBLE:
4305 case FALSE:
4306 case FLOAT:
4307 case INT:
4308 case LONG:
4309 case NEW:
4310 case NULL:
4311 case SHORT:
4312 case SUPER:
4313 case THIS:
4314 case TRUE:
4315 case VOID:
4316 case INTEGER_LITERAL:
4317 case FLOATING_POINT_LITERAL:
4318 case CHARACTER_LITERAL:
4319 case STRING_LITERAL:
4320 case IDENTIFIER:
4321 case LPAREN:
4322 case INCR:
4323 case DECR:
4324 StatementExpression();
4325 jj_consume_token(SEMICOLON);
4326 break;
4327
4328 case SWITCH:
4329 SwitchStatement();
4330 break;
4331
4332 case IF:
4333 IfStatement();
4334 break;
4335
4336 case WHILE:
4337 WhileStatement();
4338 break;
4339
4340 case DO:
4341 DoStatement();
4342 break;
4343
4344 case FOR:
4345 ForStatement();
4346 break;
4347
4348 case BREAK:
4349 BreakStatement();
4350 break;
4351
4352 case CONTINUE:
4353 ContinueStatement();
4354 break;
4355
4356 case RETURN:
4357 ReturnStatement();
4358 break;
4359
4360 case THROW:
4361 ThrowStatement();
4362 break;
4363
4364 case SYNCHRONIZED:
4365 SynchronizedStatement();
4366 break;
4367
4368 case TRY:
4369 TryStatement();
4370 break;
4371
4372 default:
4373 jj_la1[90] = jj_gen;
4374 jj_consume_token(-1);
4375 throw new ParseException();
4376 }
4377 }
4378 } catch (Throwable jjte000) {
4379 if (jjtc000) {
4380 jjtree.clearNodeScope(jjtn000);
4381 jjtc000 = false;
4382 } else {
4383 jjtree.popNode();
4384 }
4385 if (jjte000 instanceof RuntimeException ) { {
4386 if (true) {
4387 throw (RuntimeException ) jjte000;
4388 }
4389 }
4390 }
4391 if (jjte000 instanceof ParseException) { {
4392 if (true) {
4393 throw (ParseException) jjte000;
4394 }
4395 }
4396 } {
4397 if (true) {
4398 throw (Error ) jjte000;
4399 }
4400 }
4401 }
4402 finally {
4403 if (jjtc000) {
4404 jjtree.closeNodeScope(jjtn000, true);
4405 }
4406 }
4407 }
4408
4409 static final public void LabeledStatement() throws ParseException {
4410
4411
4412 SimpleNode jjtn000 = new SimpleNode(JJTLABELEDSTATEMENT);
4413 boolean jjtc000 = true;
4414
4415 jjtree.openNodeScope(jjtn000);
4416 try {
4417 jj_consume_token(IDENTIFIER);
4418 jj_consume_token(COLON);
4419 Statement();
4420 } catch (Throwable jjte000) {
4421 if (jjtc000) {
4422 jjtree.clearNodeScope(jjtn000);
4423 jjtc000 = false;
4424 } else {
4425 jjtree.popNode();
4426 }
4427 if (jjte000 instanceof RuntimeException ) { {
4428 if (true) {
4429 throw (RuntimeException ) jjte000;
4430 }
4431 }
4432 }
4433 if (jjte000 instanceof ParseException) { {
4434 if (true) {
4435 throw (ParseException) jjte000;
4436 }
4437 }
4438 } {
4439 if (true) {
4440 throw (Error ) jjte000;
4441 }
4442 }
4443 }
4444 finally {
4445 if (jjtc000) {
4446 jjtree.closeNodeScope(jjtn000, true);
4447 }
4448 }
4449 }
4450
4451 static final public void Block() throws ParseException {
4452
4453
4454 SimpleNode jjtn000 = new SimpleNode(JJTBLOCK);
4455 boolean jjtc000 = true;
4456
4457 jjtree.openNodeScope(jjtn000);
4458 try {
4459 jj_consume_token(LBRACE);
4460 label_36:
4461 while (true) {
4462 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4463 case BOOLEAN:
4464 case BREAK:
4465 case BYTE:
4466 case CHAR:
4467 case CLASS:
4468 case CONTINUE:
4469 case DO:
4470 case DOUBLE:
4471 case FALSE:
4472 case FINAL:
4473 case FLOAT:
4474 case FOR:
4475 case IF:
4476 case INT:
4477 case INTERFACE:
4478 case LONG:
4479 case NEW:
4480 case NULL:
4481 case RETURN:
4482 case SHORT:
4483 case SUPER:
4484 case SWITCH:
4485 case SYNCHRONIZED:
4486 case THIS:
4487 case THROW:
4488 case TRUE:
4489 case TRY:
4490 case VOID:
4491 case WHILE:
4492 case INTEGER_LITERAL:
4493 case FLOATING_POINT_LITERAL:
4494 case CHARACTER_LITERAL:
4495 case STRING_LITERAL:
4496 case IDENTIFIER:
4497 case LPAREN:
4498 case LBRACE:
4499 case SEMICOLON:
4500 case INCR:
4501 case DECR:
4502 ;
4503 break;
4504
4505 default:
4506 jj_la1[91] = jj_gen;
4507 break label_36;
4508 }
4509 BlockStatement();
4510 }
4511 jj_consume_token(RBRACE);
4512 } catch (Throwable jjte000) {
4513 if (jjtc000) {
4514 jjtree.clearNodeScope(jjtn000);
4515 jjtc000 = false;
4516 } else {
4517 jjtree.popNode();
4518 }
4519 if (jjte000 instanceof RuntimeException ) { {
4520 if (true) {
4521 throw (RuntimeException ) jjte000;
4522 }
4523 }
4524 }
4525 if (jjte000 instanceof ParseException) { {
4526 if (true) {
4527 throw (ParseException) jjte000;
4528 }
4529 }
4530 } {
4531 if (true) {
4532 throw (Error ) jjte000;
4533 }
4534 }
4535 }
4536 finally {
4537 if (jjtc000) {
4538 jjtree.closeNodeScope(jjtn000, true);
4539 }
4540 }
4541 }
4542
4543 static final public void BlockStatement() throws ParseException {
4544
4545
4546 SimpleNode jjtn000 = new SimpleNode(JJTBLOCKSTATEMENT);
4547 boolean jjtc000 = true;
4548
4549 jjtree.openNodeScope(jjtn000);
4550 try {
4551 if (jj_2_28(2147483647)) {
4552 LocalVariableDeclaration();
4553 jj_consume_token(SEMICOLON);
4554 } else {
4555 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4556 case BOOLEAN:
4557 case BREAK:
4558 case BYTE:
4559 case CHAR:
4560 case CONTINUE:
4561 case DO:
4562 case DOUBLE:
4563 case FALSE:
4564 case FLOAT:
4565 case FOR:
4566 case IF:
4567 case INT:
4568 case LONG:
4569 case NEW:
4570 case NULL:
4571 case RETURN:
4572 case SHORT:
4573 case SUPER:
4574 case SWITCH:
4575 case SYNCHRONIZED:
4576 case THIS:
4577 case THROW:
4578 case TRUE:
4579 case TRY:
4580 case VOID:
4581 case WHILE:
4582 case INTEGER_LITERAL:
4583 case FLOATING_POINT_LITERAL:
4584 case CHARACTER_LITERAL:
4585 case STRING_LITERAL:
4586 case IDENTIFIER:
4587 case LPAREN:
4588 case LBRACE:
4589 case SEMICOLON:
4590 case INCR:
4591 case DECR:
4592 Statement();
4593 break;
4594
4595 case CLASS:
4596 UnmodifiedClassDeclaration();
4597 break;
4598
4599 case INTERFACE:
4600 UnmodifiedInterfaceDeclaration();
4601 break;
4602
4603 default:
4604 jj_la1[92] = jj_gen;
4605 jj_consume_token(-1);
4606 throw new ParseException();
4607 }
4608 }
4609 } catch (Throwable jjte000) {
4610 if (jjtc000) {
4611 jjtree.clearNodeScope(jjtn000);
4612 jjtc000 = false;
4613 } else {
4614 jjtree.popNode();
4615 }
4616 if (jjte000 instanceof RuntimeException ) { {
4617 if (true) {
4618 throw (RuntimeException ) jjte000;
4619 }
4620 }
4621 }
4622 if (jjte000 instanceof ParseException) { {
4623 if (true) {
4624 throw (ParseException) jjte000;
4625 }
4626 }
4627 } {
4628 if (true) {
4629 throw (Error ) jjte000;
4630 }
4631 }
4632 }
4633 finally {
4634 if (jjtc000) {
4635 jjtree.closeNodeScope(jjtn000, true);
4636 }
4637 }
4638 }
4639
4640 static final public void LocalVariableDeclaration() throws ParseException {
4641
4642
4643 SimpleNode jjtn000 = new SimpleNode(JJTLOCALVARIABLEDECLARATION);
4644 boolean jjtc000 = true;
4645
4646 jjtree.openNodeScope(jjtn000);
4647 try {
4648 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4649 case FINAL:
4650 jj_consume_token(FINAL);
4651 break;
4652
4653 default:
4654 jj_la1[93] = jj_gen;
4655 ;
4656 }
4657 Type();
4658 VariableDeclarator();
4659 label_37:
4660 while (true) {
4661 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4662 case COMMA:
4663 ;
4664 break;
4665
4666 default:
4667 jj_la1[94] = jj_gen;
4668 break label_37;
4669 }
4670 jj_consume_token(COMMA);
4671 VariableDeclarator();
4672 }
4673 } catch (Throwable jjte000) {
4674 if (jjtc000) {
4675 jjtree.clearNodeScope(jjtn000);
4676 jjtc000 = false;
4677 } else {
4678 jjtree.popNode();
4679 }
4680 if (jjte000 instanceof RuntimeException ) { {
4681 if (true) {
4682 throw (RuntimeException ) jjte000;
4683 }
4684 }
4685 }
4686 if (jjte000 instanceof ParseException) { {
4687 if (true) {
4688 throw (ParseException) jjte000;
4689 }
4690 }
4691 } {
4692 if (true) {
4693 throw (Error ) jjte000;
4694 }
4695 }
4696 }
4697 finally {
4698 if (jjtc000) {
4699 jjtree.closeNodeScope(jjtn000, true);
4700 }
4701 }
4702 }
4703
4704 static final public void EmptyStatement() throws ParseException {
4705
4706
4707 SimpleNode jjtn000 = new SimpleNode(JJTEMPTYSTATEMENT);
4708 boolean jjtc000 = true;
4709
4710 jjtree.openNodeScope(jjtn000);
4711 try {
4712 jj_consume_token(SEMICOLON);
4713 }
4714 finally {
4715 if (jjtc000) {
4716 jjtree.closeNodeScope(jjtn000, true);
4717 }
4718 }
4719 }
4720
4721 static final public void StatementExpression() throws ParseException {
4722
4723
4724 SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENTEXPRESSION);
4725 boolean jjtc000 = true;
4726
4727 jjtree.openNodeScope(jjtn000);
4728 try {
4729 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4730 case INCR:
4731 PreIncrementExpression();
4732 break;
4733
4734 case DECR:
4735 PreDecrementExpression();
4736 break;
4737
4738 case BOOLEAN:
4739 case BYTE:
4740 case CHAR:
4741 case DOUBLE:
4742 case FALSE:
4743 case FLOAT:
4744 case INT:
4745 case LONG:
4746 case NEW:
4747 case NULL:
4748 case SHORT:
4749 case SUPER:
4750 case THIS:
4751 case TRUE:
4752 case VOID:
4753 case INTEGER_LITERAL:
4754 case FLOATING_POINT_LITERAL:
4755 case CHARACTER_LITERAL:
4756 case STRING_LITERAL:
4757 case IDENTIFIER:
4758 case LPAREN:
4759 PrimaryExpression();
4760 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4761 case ASSIGN:
4762 case INCR:
4763 case DECR:
4764 case PLUSASSIGN:
4765 case MINUSASSIGN:
4766 case STARASSIGN:
4767 case SLASHASSIGN:
4768 case ANDASSIGN:
4769 case ORASSIGN:
4770 case XORASSIGN:
4771 case REMASSIGN:
4772 case LSHIFTASSIGN:
4773 case RSIGNEDSHIFTASSIGN:
4774 case RUNSIGNEDSHIFTASSIGN:
4775 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4776 case INCR:
4777 jj_consume_token(INCR);
4778 break;
4779
4780 case DECR:
4781 jj_consume_token(DECR);
4782 break;
4783
4784 case ASSIGN:
4785 case PLUSASSIGN:
4786 case MINUSASSIGN:
4787 case STARASSIGN:
4788 case SLASHASSIGN:
4789 case ANDASSIGN:
4790 case ORASSIGN:
4791 case XORASSIGN:
4792 case REMASSIGN:
4793 case LSHIFTASSIGN:
4794 case RSIGNEDSHIFTASSIGN:
4795 case RUNSIGNEDSHIFTASSIGN:
4796 AssignmentOperator();
4797 Expression();
4798 break;
4799
4800 default:
4801 jj_la1[95] = jj_gen;
4802 jj_consume_token(-1);
4803 throw new ParseException();
4804 }
4805 break;
4806
4807 default:
4808 jj_la1[96] = jj_gen;
4809 ;
4810 }
4811 break;
4812
4813 default:
4814 jj_la1[97] = jj_gen;
4815 jj_consume_token(-1);
4816 throw new ParseException();
4817 }
4818 } catch (Throwable jjte000) {
4819 if (jjtc000) {
4820 jjtree.clearNodeScope(jjtn000);
4821 jjtc000 = false;
4822 } else {
4823 jjtree.popNode();
4824 }
4825 if (jjte000 instanceof RuntimeException ) { {
4826 if (true) {
4827 throw (RuntimeException ) jjte000;
4828 }
4829 }
4830 }
4831 if (jjte000 instanceof ParseException) { {
4832 if (true) {
4833 throw (ParseException) jjte000;
4834 }
4835 }
4836 } {
4837 if (true) {
4838 throw (Error ) jjte000;
4839 }
4840 }
4841 }
4842 finally {
4843 if (jjtc000) {
4844 jjtree.closeNodeScope(jjtn000, true);
4845 }
4846 }
4847 }
4848
4849 static final public void SwitchStatement() throws ParseException {
4850
4851
4852 SimpleNode jjtn000 = new SimpleNode(JJTSWITCHSTATEMENT);
4853 boolean jjtc000 = true;
4854
4855 jjtree.openNodeScope(jjtn000);
4856 try {
4857 jj_consume_token(SWITCH);
4858 jj_consume_token(LPAREN);
4859 Expression();
4860 jj_consume_token(RPAREN);
4861 jj_consume_token(LBRACE);
4862 label_38:
4863 while (true) {
4864 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4865 case CASE:
4866 case _DEFAULT:
4867 ;
4868 break;
4869
4870 default:
4871 jj_la1[98] = jj_gen;
4872 break label_38;
4873 }
4874 SwitchLabel();
4875 label_39:
4876 while (true) {
4877 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4878 case BOOLEAN:
4879 case BREAK:
4880 case BYTE:
4881 case CHAR:
4882 case CLASS:
4883 case CONTINUE:
4884 case DO:
4885 case DOUBLE:
4886 case FALSE:
4887 case FINAL:
4888 case FLOAT:
4889 case FOR:
4890 case IF:
4891 case INT:
4892 case INTERFACE:
4893 case LONG:
4894 case NEW:
4895 case NULL:
4896 case RETURN:
4897 case SHORT:
4898 case SUPER:
4899 case SWITCH:
4900 case SYNCHRONIZED:
4901 case THIS:
4902 case THROW:
4903 case TRUE:
4904 case TRY:
4905 case VOID:
4906 case WHILE:
4907 case INTEGER_LITERAL:
4908 case FLOATING_POINT_LITERAL:
4909 case CHARACTER_LITERAL:
4910 case STRING_LITERAL:
4911 case IDENTIFIER:
4912 case LPAREN:
4913 case LBRACE:
4914 case SEMICOLON:
4915 case INCR:
4916 case DECR:
4917 ;
4918 break;
4919
4920 default:
4921 jj_la1[99] = jj_gen;
4922 break label_39;
4923 }
4924 BlockStatement();
4925 }
4926 }
4927 jj_consume_token(RBRACE);
4928 } catch (Throwable jjte000) {
4929 if (jjtc000) {
4930 jjtree.clearNodeScope(jjtn000);
4931 jjtc000 = false;
4932 } else {
4933 jjtree.popNode();
4934 }
4935 if (jjte000 instanceof RuntimeException ) { {
4936 if (true) {
4937 throw (RuntimeException ) jjte000;
4938 }
4939 }
4940 }
4941 if (jjte000 instanceof ParseException) { {
4942 if (true) {
4943 throw (ParseException) jjte000;
4944 }
4945 }
4946 } {
4947 if (true) {
4948 throw (Error ) jjte000;
4949 }
4950 }
4951 }
4952 finally {
4953 if (jjtc000) {
4954 jjtree.closeNodeScope(jjtn000, true);
4955 }
4956 }
4957 }
4958
4959 static final public void SwitchLabel() throws ParseException {
4960
4961
4962 SimpleNode jjtn000 = new SimpleNode(JJTSWITCHLABEL);
4963 boolean jjtc000 = true;
4964
4965 jjtree.openNodeScope(jjtn000);
4966 try {
4967 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4968 case CASE:
4969 jj_consume_token(CASE);
4970 Expression();
4971 jj_consume_token(COLON);
4972 break;
4973
4974 case _DEFAULT:
4975 jj_consume_token(_DEFAULT);
4976 jj_consume_token(COLON);
4977 break;
4978
4979 default:
4980 jj_la1[100] = jj_gen;
4981 jj_consume_token(-1);
4982 throw new ParseException();
4983 }
4984 } catch (Throwable jjte000) {
4985 if (jjtc000) {
4986 jjtree.clearNodeScope(jjtn000);
4987 jjtc000 = false;
4988 } else {
4989 jjtree.popNode();
4990 }
4991 if (jjte000 instanceof RuntimeException ) { {
4992 if (true) {
4993 throw (RuntimeException ) jjte000;
4994 }
4995 }
4996 }
4997 if (jjte000 instanceof ParseException) { {
4998 if (true) {
4999 throw (ParseException) jjte000;
5000 }
5001 }
5002 } {
5003 if (true) {
5004 throw (Error ) jjte000;
5005 }
5006 }
5007 }
5008 finally {
5009 if (jjtc000) {
5010 jjtree.closeNodeScope(jjtn000, true);
5011 }
5012 }
5013 }
5014
5015 static final public void IfStatement() throws ParseException {
5016
5017
5018 SimpleNode jjtn000 = new SimpleNode(JJTIFSTATEMENT);
5019 boolean jjtc000 = true;
5020
5021 jjtree.openNodeScope(jjtn000);
5022 try {
5023 jj_consume_token(IF);
5024 jj_consume_token(LPAREN);
5025 Expression();
5026 jj_consume_token(RPAREN);
5027 Statement();
5028 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5029 case ELSE:
5030 jj_consume_token(ELSE);
5031 Statement();
5032 break;
5033
5034 default:
5035 jj_la1[101] = jj_gen;
5036 ;
5037 }
5038 } catch (Throwable jjte000) {
5039 if (jjtc000) {
5040 jjtree.clearNodeScope(jjtn000);
5041 jjtc000 = false;
5042 } else {
5043 jjtree.popNode();
5044 }
5045 if (jjte000 instanceof RuntimeException ) { {
5046 if (true) {
5047 throw (RuntimeException ) jjte000;
5048 }
5049 }
5050 }
5051 if (jjte000 instanceof ParseException) { {
5052 if (true) {
5053 throw (ParseException) jjte000;
5054 }
5055 }
5056 } {
5057 if (true) {
5058 throw (Error ) jjte000;
5059 }
5060 }
5061 }
5062 finally {
5063 if (jjtc000) {
5064 jjtree.closeNodeScope(jjtn000, true);
5065 }
5066 }
5067 }
5068
5069 static final public void WhileStatement() throws ParseException {
5070
5071
5072 SimpleNode jjtn000 = new SimpleNode(JJTWHILESTATEMENT);
5073 boolean jjtc000 = true;
5074
5075 jjtree.openNodeScope(jjtn000);
5076 try {
5077 jj_consume_token(WHILE);
5078 jj_consume_token(LPAREN);
5079 Expression();
5080 jj_consume_token(RPAREN);
5081 Statement();
5082 } catch (Throwable jjte000) {
5083 if (jjtc000) {
5084 jjtree.clearNodeScope(jjtn000);
5085 jjtc000 = false;
5086 } else {
5087 jjtree.popNode();
5088 }
5089 if (jjte000 instanceof RuntimeException ) { {
5090 if (true) {
5091 throw (RuntimeException ) jjte000;
5092 }
5093 }
5094 }
5095 if (jjte000 instanceof ParseException) { {
5096 if (true) {
5097 throw (ParseException) jjte000;
5098 }
5099 }
5100 } {
5101 if (true) {
5102 throw (Error ) jjte000;
5103 }
5104 }
5105 }
5106 finally {
5107 if (jjtc000) {
5108 jjtree.closeNodeScope(jjtn000, true);
5109 }
5110 }
5111 }
5112
5113 static final public void DoStatement() throws ParseException {
5114
5115
5116 SimpleNode jjtn000 = new SimpleNode(JJTDOSTATEMENT);
5117 boolean jjtc000 = true;
5118
5119 jjtree.openNodeScope(jjtn000);
5120 try {
5121 jj_consume_token(DO);
5122 Statement();
5123 jj_consume_token(WHILE);
5124 jj_consume_token(LPAREN);
5125 Expression();
5126 jj_consume_token(RPAREN);
5127 jj_consume_token(SEMICOLON);
5128 } catch (Throwable jjte000) {
5129 if (jjtc000) {
5130 jjtree.clearNodeScope(jjtn000);
5131 jjtc000 = false;
5132 } else {
5133 jjtree.popNode();
5134 }
5135 if (jjte000 instanceof RuntimeException ) { {
5136 if (true) {
5137 throw (RuntimeException ) jjte000;
5138 }
5139 }
5140 }
5141 if (jjte000 instanceof ParseException) { {
5142 if (true) {
5143 throw (ParseException) jjte000;
5144 }
5145 }
5146 } {
5147 if (true) {
5148 throw (Error ) jjte000;
5149 }
5150 }
5151 }
5152 finally {
5153 if (jjtc000) {
5154 jjtree.closeNodeScope(jjtn000, true);
5155 }
5156 }
5157 }
5158
5159 static final public void ForStatement() throws ParseException {
5160
5161
5162 SimpleNode jjtn000 = new SimpleNode(JJTFORSTATEMENT);
5163 boolean jjtc000 = true;
5164
5165 jjtree.openNodeScope(jjtn000);
5166 try {
5167 jj_consume_token(FOR);
5168 jj_consume_token(LPAREN);
5169 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5170 case BOOLEAN:
5171 case BYTE:
5172 case CHAR:
5173 case DOUBLE:
5174 case FALSE:
5175 case FINAL:
5176 case FLOAT:
5177 case INT:
5178 case LONG:
5179 case NEW:
5180 case NULL:
5181 case SHORT:
5182 case SUPER:
5183 case THIS:
5184 case TRUE:
5185 case VOID:
5186 case INTEGER_LITERAL:
5187 case FLOATING_POINT_LITERAL:
5188 case CHARACTER_LITERAL:
5189 case STRING_LITERAL:
5190 case IDENTIFIER:
5191 case LPAREN:
5192 case INCR:
5193 case DECR:
5194 ForInit();
5195 break;
5196
5197 default:
5198 jj_la1[102] = jj_gen;
5199 ;
5200 }
5201 jj_consume_token(SEMICOLON);
5202 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5203 case BOOLEAN:
5204 case BYTE:
5205 case CHAR:
5206 case DOUBLE:
5207 case FALSE:
5208 case FLOAT:
5209 case INT:
5210 case LONG:
5211 case NEW:
5212 case NULL:
5213 case SHORT:
5214 case SUPER:
5215 case THIS:
5216 case TRUE:
5217 case VOID:
5218 case INTEGER_LITERAL:
5219 case FLOATING_POINT_LITERAL:
5220 case CHARACTER_LITERAL:
5221 case STRING_LITERAL:
5222 case IDENTIFIER:
5223 case LPAREN:
5224 case BANG:
5225 case TILDE:
5226 case INCR:
5227 case DECR:
5228 case PLUS:
5229 case MINUS:
5230 Expression();
5231 break;
5232
5233 default:
5234 jj_la1[103] = jj_gen;
5235 ;
5236 }
5237 jj_consume_token(SEMICOLON);
5238 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5239 case BOOLEAN:
5240 case BYTE:
5241 case CHAR:
5242 case DOUBLE:
5243 case FALSE:
5244 case FLOAT:
5245 case INT:
5246 case LONG:
5247 case NEW:
5248 case NULL:
5249 case SHORT:
5250 case SUPER:
5251 case THIS:
5252 case TRUE:
5253 case VOID:
5254 case INTEGER_LITERAL:
5255 case FLOATING_POINT_LITERAL:
5256 case CHARACTER_LITERAL:
5257 case STRING_LITERAL:
5258 case IDENTIFIER:
5259 case LPAREN:
5260 case INCR:
5261 case DECR:
5262 ForUpdate();
5263 break;
5264
5265 default:
5266 jj_la1[104] = jj_gen;
5267 ;
5268 }
5269 jj_consume_token(RPAREN);
5270 Statement();
5271 } catch (Throwable jjte000) {
5272 if (jjtc000) {
5273 jjtree.clearNodeScope(jjtn000);
5274 jjtc000 = false;
5275 } else {
5276 jjtree.popNode();
5277 }
5278 if (jjte000 instanceof RuntimeException ) { {
5279 if (true) {
5280 throw (RuntimeException ) jjte000;
5281 }
5282 }
5283 }
5284 if (jjte000 instanceof ParseException) { {
5285 if (true) {
5286 throw (ParseException) jjte000;
5287 }
5288 }
5289 } {
5290 if (true) {
5291 throw (Error ) jjte000;
5292 }
5293 }
5294 }
5295 finally {
5296 if (jjtc000) {
5297 jjtree.closeNodeScope(jjtn000, true);
5298 }
5299 }
5300 }
5301
5302 static final public void ForInit() throws ParseException {
5303
5304
5305 SimpleNode jjtn000 = new SimpleNode(JJTFORINIT);
5306 boolean jjtc000 = true;
5307
5308 jjtree.openNodeScope(jjtn000);
5309 try {
5310 if (jj_2_29(2147483647)) {
5311 LocalVariableDeclaration();
5312 } else {
5313 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5314 case BOOLEAN:
5315 case BYTE:
5316 case CHAR:
5317 case DOUBLE:
5318 case FALSE:
5319 case FLOAT:
5320 case INT:
5321 case LONG:
5322 case NEW:
5323 case NULL:
5324 case SHORT:
5325 case SUPER:
5326 case THIS:
5327 case TRUE:
5328 case VOID:
5329 case INTEGER_LITERAL:
5330 case FLOATING_POINT_LITERAL:
5331 case CHARACTER_LITERAL:
5332 case STRING_LITERAL:
5333 case IDENTIFIER:
5334 case LPAREN:
5335 case INCR:
5336 case DECR:
5337 StatementExpressionList();
5338 break;
5339
5340 default:
5341 jj_la1[105] = jj_gen;
5342 jj_consume_token(-1);
5343 throw new ParseException();
5344 }
5345 }
5346 } catch (Throwable jjte000) {
5347 if (jjtc000) {
5348 jjtree.clearNodeScope(jjtn000);
5349 jjtc000 = false;
5350 } else {
5351 jjtree.popNode();
5352 }
5353 if (jjte000 instanceof RuntimeException ) { {
5354 if (true) {
5355 throw (RuntimeException ) jjte000;
5356 }
5357 }
5358 }
5359 if (jjte000 instanceof ParseException) { {
5360 if (true) {
5361 throw (ParseException) jjte000;
5362 }
5363 }
5364 } {
5365 if (true) {
5366 throw (Error ) jjte000;
5367 }
5368 }
5369 }
5370 finally {
5371 if (jjtc000) {
5372 jjtree.closeNodeScope(jjtn000, true);
5373 }
5374 }
5375 }
5376
5377 static final public void StatementExpressionList() throws ParseException {
5378
5379
5380 SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENTEXPRESSIONLIST);
5381 boolean jjtc000 = true;
5382
5383 jjtree.openNodeScope(jjtn000);
5384 try {
5385 StatementExpression();
5386 label_40:
5387 while (true) {
5388 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5389 case COMMA:
5390 ;
5391 break;
5392
5393 default:
5394 jj_la1[106] = jj_gen;
5395 break label_40;
5396 }
5397 jj_consume_token(COMMA);
5398 StatementExpression();
5399 }
5400 } catch (Throwable jjte000) {
5401 if (jjtc000) {
5402 jjtree.clearNodeScope(jjtn000);
5403 jjtc000 = false;
5404 } else {
5405 jjtree.popNode();
5406 }
5407 if (jjte000 instanceof RuntimeException ) { {
5408 if (true) {
5409 throw (RuntimeException ) jjte000;
5410 }
5411 }
5412 }
5413 if (jjte000 instanceof ParseException) { {
5414 if (true) {
5415 throw (ParseException) jjte000;
5416 }
5417 }
5418 } {
5419 if (true) {
5420 throw (Error ) jjte000;
5421 }
5422 }
5423 }
5424 finally {
5425 if (jjtc000) {
5426 jjtree.closeNodeScope(jjtn000, true);
5427 }
5428 }
5429 }
5430
5431 static final public void ForUpdate() throws ParseException {
5432
5433
5434 SimpleNode jjtn000 = new SimpleNode(JJTFORUPDATE);
5435 boolean jjtc000 = true;
5436
5437 jjtree.openNodeScope(jjtn000);
5438 try {
5439 StatementExpressionList();
5440 } catch (Throwable jjte000) {
5441 if (jjtc000) {
5442 jjtree.clearNodeScope(jjtn000);
5443 jjtc000 = false;
5444 } else {
5445 jjtree.popNode();
5446 }
5447 if (jjte000 instanceof RuntimeException ) { {
5448 if (true) {
5449 throw (RuntimeException ) jjte000;
5450 }
5451 }
5452 }
5453 if (jjte000 instanceof ParseException) { {
5454 if (true) {
5455 throw (ParseException) jjte000;
5456 }
5457 }
5458 } {
5459 if (true) {
5460 throw (Error ) jjte000;
5461 }
5462 }
5463 }
5464 finally {
5465 if (jjtc000) {
5466 jjtree.closeNodeScope(jjtn000, true);
5467 }
5468 }
5469 }
5470
5471 static final public void BreakStatement() throws ParseException {
5472
5473
5474 SimpleNode jjtn000 = new SimpleNode(JJTBREAKSTATEMENT);
5475 boolean jjtc000 = true;
5476
5477 jjtree.openNodeScope(jjtn000);
5478 try {
5479 jj_consume_token(BREAK);
5480 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5481 case IDENTIFIER:
5482 jj_consume_token(IDENTIFIER);
5483 break;
5484
5485 default:
5486 jj_la1[107] = jj_gen;
5487 ;
5488 }
5489 jj_consume_token(SEMICOLON);
5490 }
5491 finally {
5492 if (jjtc000) {
5493 jjtree.closeNodeScope(jjtn000, true);
5494 }
5495 }
5496 }
5497
5498 static final public void ContinueStatement() throws ParseException {
5499
5500
5501 SimpleNode jjtn000 = new SimpleNode(JJTCONTINUESTATEMENT);
5502 boolean jjtc000 = true;
5503
5504 jjtree.openNodeScope(jjtn000);
5505 try {
5506 jj_consume_token(CONTINUE);
5507 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5508 case IDENTIFIER:
5509 jj_consume_token(IDENTIFIER);
5510 break;
5511
5512 default:
5513 jj_la1[108] = jj_gen;
5514 ;
5515 }
5516 jj_consume_token(SEMICOLON);
5517 }
5518 finally {
5519 if (jjtc000) {
5520 jjtree.closeNodeScope(jjtn000, true);
5521 }
5522 }
5523 }
5524
5525 static final public void ReturnStatement() throws ParseException {
5526
5527
5528 SimpleNode jjtn000 = new SimpleNode(JJTRETURNSTATEMENT);
5529 boolean jjtc000 = true;
5530
5531 jjtree.openNodeScope(jjtn000);
5532 try {
5533 jj_consume_token(RETURN);
5534 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5535 case BOOLEAN:
5536 case BYTE:
5537 case CHAR:
5538 case DOUBLE:
5539 case FALSE:
5540 case FLOAT:
5541 case INT:
5542 case LONG:
5543 case NEW:
5544 case NULL:
5545 case SHORT:
5546 case SUPER:
5547 case THIS:
5548 case TRUE:
5549 case VOID:
5550 case INTEGER_LITERAL:
5551 case FLOATING_POINT_LITERAL:
5552 case CHARACTER_LITERAL:
5553 case STRING_LITERAL:
5554 case IDENTIFIER:
5555 case LPAREN:
5556 case BANG:
5557 case TILDE:
5558 case INCR:
5559 case DECR:
5560 case PLUS:
5561 case MINUS:
5562 Expression();
5563 break;
5564
5565 default:
5566 jj_la1[109] = jj_gen;
5567 ;
5568 }
5569 jj_consume_token(SEMICOLON);
5570 } catch (Throwable jjte000) {
5571 if (jjtc000) {
5572 jjtree.clearNodeScope(jjtn000);
5573 jjtc000 = false;
5574 } else {
5575 jjtree.popNode();
5576 }
5577 if (jjte000 instanceof RuntimeException ) { {
5578 if (true) {
5579 throw (RuntimeException ) jjte000;
5580 }
5581 }
5582 }
5583 if (jjte000 instanceof ParseException) { {
5584 if (true) {
5585 throw (ParseException) jjte000;
5586 }
5587 }
5588 } {
5589 if (true) {
5590 throw (Error ) jjte000;
5591 }
5592 }
5593 }
5594 finally {
5595 if (jjtc000) {
5596 jjtree.closeNodeScope(jjtn000, true);
5597 }
5598 }
5599 }
5600
5601 static final public void ThrowStatement() throws ParseException {
5602
5603
5604 SimpleNode jjtn000 = new SimpleNode(JJTTHROWSTATEMENT);
5605 boolean jjtc000 = true;
5606
5607 jjtree.openNodeScope(jjtn000);
5608 try {
5609 jj_consume_token(THROW);
5610 Expression();
5611 jj_consume_token(SEMICOLON);
5612 } catch (Throwable jjte000) {
5613 if (jjtc000) {
5614 jjtree.clearNodeScope(jjtn000);
5615 jjtc000 = false;
5616 } else {
5617 jjtree.popNode();
5618 }
5619 if (jjte000 instanceof RuntimeException ) { {
5620 if (true) {
5621 throw (RuntimeException ) jjte000;
5622 }
5623 }
5624 }
5625 if (jjte000 instanceof ParseException) { {
5626 if (true) {
5627 throw (ParseException) jjte000;
5628 }
5629 }
5630 } {
5631 if (true) {
5632 throw (Error ) jjte000;
5633 }
5634 }
5635 }
5636 finally {
5637 if (jjtc000) {
5638 jjtree.closeNodeScope(jjtn000, true);
5639 }
5640 }
5641 }
5642
5643 static final public void SynchronizedStatement() throws ParseException {
5644
5645
5646 SimpleNode jjtn000 = new SimpleNode(JJTSYNCHRONIZEDSTATEMENT);
5647 boolean jjtc000 = true;
5648
5649 jjtree.openNodeScope(jjtn000);
5650 try {
5651 jj_consume_token(SYNCHRONIZED);
5652 jj_consume_token(LPAREN);
5653 Expression();
5654 jj_consume_token(RPAREN);
5655 Block();
5656 } catch (Throwable jjte000) {
5657 if (jjtc000) {
5658 jjtree.clearNodeScope(jjtn000);
5659 jjtc000 = false;
5660 } else {
5661 jjtree.popNode();
5662 }
5663 if (jjte000 instanceof RuntimeException ) { {
5664 if (true) {
5665 throw (RuntimeException ) jjte000;
5666 }
5667 }
5668 }
5669 if (jjte000 instanceof ParseException) { {
5670 if (true) {
5671 throw (ParseException) jjte000;
5672 }
5673 }
5674 } {
5675 if (true) {
5676 throw (Error ) jjte000;
5677 }
5678 }
5679 }
5680 finally {
5681 if (jjtc000) {
5682 jjtree.closeNodeScope(jjtn000, true);
5683 }
5684 }
5685 }
5686
5687 static final public void TryStatement() throws ParseException {
5688
5689
5690 SimpleNode jjtn000 = new SimpleNode(JJTTRYSTATEMENT);
5691 boolean jjtc000 = true;
5692
5693 jjtree.openNodeScope(jjtn000);
5694 try {
5695 jj_consume_token(TRY);
5696 Block();
5697 label_41:
5698 while (true) {
5699 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5700 case CATCH:
5701 ;
5702 break;
5703
5704 default:
5705 jj_la1[110] = jj_gen;
5706 break label_41;
5707 }
5708 jj_consume_token(CATCH);
5709 jj_consume_token(LPAREN);
5710 FormalParameter();
5711 jj_consume_token(RPAREN);
5712 Block();
5713 }
5714 switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
5715 case FINALLY:
5716 jj_consume_token(FINALLY);
5717 Block();
5718 break;
5719
5720 default:
5721 jj_la1[111] = jj_gen;
5722 ;
5723 }
5724 } catch (Throwable jjte000) {
5725 if (jjtc000) {
5726 jjtree.clearNodeScope(jjtn000);
5727 jjtc000 = false;
5728 } else {
5729 jjtree.popNode();
5730 }
5731 if (jjte000 instanceof RuntimeException ) { {
5732 if (true) {
5733 throw (RuntimeException ) jjte000;
5734 }
5735 }
5736 }
5737 if (jjte000 instanceof ParseException) { {
5738 if (true) {
5739 throw (ParseException) jjte000;
5740 }
5741 }
5742 } {
5743 if (true) {
5744 throw (Error ) jjte000;
5745 }
5746 }
5747 }
5748 finally {
5749 if (jjtc000) {
5750 jjtree.closeNodeScope(jjtn000, true);
5751 }
5752 }
5753 }
5754
5755 static final private boolean jj_2_1(int xla) {
5756 jj_la = xla;
5757 jj_lastpos = jj_scanpos = token;
5758 boolean retval = !jj_3_1();
5759
5760 jj_save(0, xla);
5761 return retval;
5762 }
5763
5764 static final private boolean jj_2_2(int xla) {
5765 jj_la = xla;
5766 jj_lastpos = jj_scanpos = token;
5767 boolean retval = !jj_3_2();
5768
5769 jj_save(1, xla);
5770 return retval;
5771 }
5772
5773 static final private boolean jj_2_3(int xla) {
5774 jj_la = xla;
5775 jj_lastpos = jj_scanpos = token;
5776 boolean retval = !jj_3_3();
5777
5778 jj_save(2, xla);
5779 return retval;
5780 }
5781
5782 static final private boolean jj_2_4(int xla) {
5783 jj_la = xla;
5784 jj_lastpos = jj_scanpos = token;
5785 boolean retval = !jj_3_4();
5786
5787 jj_save(3, xla);
5788 return retval;
5789 }
5790
5791 static final private boolean jj_2_5(int xla) {
5792 jj_la = xla;
5793 jj_lastpos = jj_scanpos = token;
5794 boolean retval = !jj_3_5();
5795
5796 jj_save(4, xla);
5797 return retval;
5798 }
5799
5800 static final private boolean jj_2_6(int xla) {
5801 jj_la = xla;
5802 jj_lastpos = jj_scanpos = token;
5803 boolean retval = !jj_3_6();
5804
5805 jj_save(5, xla);
5806 return retval;
5807 }
5808
5809 static final private boolean jj_2_7(int xla) {
5810 jj_la = xla;
5811 jj_lastpos = jj_scanpos = token;
5812 boolean retval = !jj_3_7();
5813
5814 jj_save(6, xla);
5815 return retval;
5816 }
5817
5818 static final private boolean jj_2_8(int xla) {
5819 jj_la = xla;
5820 jj_lastpos = jj_scanpos = token;
5821 boolean retval = !jj_3_8();
5822
5823 jj_save(7, xla);
5824 return retval;
5825 }
5826
5827 static final private boolean jj_2_9(int xla) {
5828 jj_la = xla;
5829 jj_lastpos = jj_scanpos = token;
5830 boolean retval = !jj_3_9();
5831
5832 jj_save(8, xla);
5833 return retval;
5834 }
5835
5836 static final private boolean jj_2_10(int xla) {
5837 jj_la = xla;
5838 jj_lastpos = jj_scanpos = token;
5839 boolean retval = !jj_3_10();
5840
5841 jj_save(9, xla);
5842 return retval;
5843 }
5844
5845 static final private boolean jj_2_11(int xla) {
5846 jj_la = xla;
5847 jj_lastpos = jj_scanpos = token;
5848 boolean retval = !jj_3_11();
5849
5850 jj_save(10, xla);
5851 return retval;
5852 }
5853
5854 static final private boolean jj_2_12(int xla) {
5855 jj_la = xla;
5856 jj_lastpos = jj_scanpos = token;
5857 boolean retval = !jj_3_12();
5858
5859 jj_save(11, xla);
5860 return retval;
5861 }
5862
5863 static final private boolean jj_2_13(int xla) {
5864 jj_la = xla;
5865 jj_lastpos = jj_scanpos = token;
5866 boolean retval = !jj_3_13();
5867
5868 jj_save(12, xla);
5869 return retval;
5870 }
5871
5872 static final private boolean jj_2_14(int xla) {
5873 jj_la = xla;
5874 jj_lastpos = jj_scanpos = token;
5875 boolean retval = !jj_3_14();
5876
5877 jj_save(13, xla);
5878 return retval;
5879 }
5880
5881 static final private boolean jj_2_15(int xla) {
5882 jj_la = xla;
5883 jj_lastpos = jj_scanpos = token;
5884 boolean retval = !jj_3_15();
5885
5886 jj_save(14, xla);
5887 return retval;
5888 }
5889
5890 static final private boolean jj_2_16(int xla) {
5891 jj_la = xla;
5892 jj_lastpos = jj_scanpos = token;
5893 boolean retval = !jj_3_16();
5894
5895 jj_save(15, xla);
5896 return retval;
5897 }
5898
5899 static final private boolean jj_2_17(int xla) {
5900 jj_la = xla;
5901 jj_lastpos = jj_scanpos = token;
5902 boolean retval = !jj_3_17();
5903
5904 jj_save(16, xla);
5905 return retval;
5906 }
5907
5908 static final private boolean jj_2_18(int xla) {
5909 jj_la = xla;
5910 jj_lastpos = jj_scanpos = token;
5911 boolean retval = !jj_3_18();
5912
5913 jj_save(17, xla);
5914 return retval;
5915 }
5916
5917 static final private boolean jj_2_19(int xla) {
5918 jj_la = xla;
5919 jj_lastpos = jj_scanpos = token;
5920 boolean retval = !jj_3_19();
5921
5922 jj_save(18, xla);
5923 return retval;
5924 }
5925
5926 static final private boolean jj_2_20(int xla) {
5927 jj_la = xla;
5928 jj_lastpos = jj_scanpos = token;
5929 boolean retval = !jj_3_20();
5930
5931 jj_save(19, xla);
5932 return retval;
5933 }
5934
5935 static final private boolean jj_2_21(int xla) {
5936 jj_la = xla;
5937 jj_lastpos = jj_scanpos = token;
5938 boolean retval = !jj_3_21();
5939
5940 jj_save(20, xla);
5941 return retval;
5942 }
5943
5944 static final private boolean jj_2_22(int xla) {
5945 jj_la = xla;
5946 jj_lastpos = jj_scanpos = token;
5947 boolean retval = !jj_3_22();
5948
5949 jj_save(21, xla);
5950 return retval;
5951 }
5952
5953 static final private boolean jj_2_23(int xla) {
5954 jj_la = xla;
5955 jj_lastpos = jj_scanpos = token;
5956 boolean retval = !jj_3_23();
5957
5958 jj_save(22, xla);
5959 return retval;
5960 }
5961
5962 static final private boolean jj_2_24(int xla) {
5963 jj_la = xla;
5964 jj_lastpos = jj_scanpos = token;
5965 boolean retval = !jj_3_24();
5966
5967 jj_save(23, xla);
5968 return retval;
5969 }
5970
5971 static final private boolean jj_2_25(int xla) {
5972 jj_la = xla;
5973 jj_lastpos = jj_scanpos = token;
5974 boolean retval = !jj_3_25();
5975
5976 jj_save(24, xla);
5977 return retval;
5978 }
5979
5980 static final private boolean jj_2_26(int xla) {
5981 jj_la = xla;
5982 jj_lastpos = jj_scanpos = token;
5983 boolean retval = !jj_3_26();
5984
5985 jj_save(25, xla);
5986 return retval;
5987 }
5988
5989 static final private boolean jj_2_27(int xla) {
5990 jj_la = xla;
5991 jj_lastpos = jj_scanpos = token;
5992 boolean retval = !jj_3_27();
5993
5994 jj_save(26, xla);
5995 return retval;
5996 }
5997
5998 static final private boolean jj_2_28(int xla) {
5999 jj_la = xla;
6000 jj_lastpos = jj_scanpos = token;
6001 boolean retval = !jj_3_28();
6002
6003 jj_save(27, xla);
6004 return retval;
6005 }
6006
6007 static final private boolean jj_2_29(int xla) {
6008 jj_la = xla;
6009 jj_lastpos = jj_scanpos = token;
6010 boolean retval = !jj_3_29();
6011
6012 jj_save(28, xla);
6013 return retval;
6014 }
6015
6016 static final private boolean jj_3R_364() {
6017 if (jj_scan_token(LPAREN)) {
6018 return true;
6019 }
6020 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6021 return false;
6022 }
6023 if (jj_3R_63()) {
6024 return true;
6025 }
6026 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6027 return false;
6028 }
6029 if (jj_scan_token(RPAREN)) {
6030 return true;
6031 }
6032 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6033 return false;
6034 }
6035 if (jj_3R_262()) {
6036 return true;
6037 }
6038 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6039 return false;
6040 }
6041 return false;
6042 }
6043
6044 static final private boolean jj_3R_357() {
6045 Token xsp;
6046
6047 xsp = jj_scanpos;
6048 if (jj_3R_364()) {
6049 jj_scanpos = xsp;
6050 if (jj_3R_365()) {
6051 return true;
6052 }
6053 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6054 return false;
6055 }
6056 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6057 return false;
6058 }
6059 return false;
6060 }
6061
6062 static final private boolean jj_3_17() {
6063 if (jj_scan_token(LPAREN)) {
6064 return true;
6065 }
6066 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6067 return false;
6068 }
6069 if (jj_3R_47()) {
6070 return true;
6071 }
6072 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6073 return false;
6074 }
6075 if (jj_scan_token(LBRACKET)) {
6076 return true;
6077 }
6078 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6079 return false;
6080 }
6081 return false;
6082 }
6083
6084 static final private boolean jj_3R_358() {
6085 if (jj_3R_53()) {
6086 return true;
6087 }
6088 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6089 return false;
6090 }
6091 Token xsp;
6092
6093 xsp = jj_scanpos;
6094 if (jj_3R_377()) {
6095 jj_scanpos = xsp;
6096 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6097 return false;
6098 }
6099 return false;
6100 }
6101
6102 static final private boolean jj_3R_110() {
6103 if (jj_scan_token(LPAREN)) {
6104 return true;
6105 }
6106 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6107 return false;
6108 }
6109 if (jj_3R_47()) {
6110 return true;
6111 }
6112 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6113 return false;
6114 }
6115 if (jj_scan_token(RPAREN)) {
6116 return true;
6117 }
6118 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6119 return false;
6120 }
6121 Token xsp;
6122
6123 xsp = jj_scanpos;
6124 if (jj_3R_148()) {
6125 jj_scanpos = xsp;
6126 if (jj_3R_149()) {
6127 jj_scanpos = xsp;
6128 if (jj_3R_150()) {
6129 jj_scanpos = xsp;
6130 if (jj_3R_151()) {
6131 jj_scanpos = xsp;
6132 if (jj_3R_152()) {
6133 jj_scanpos = xsp;
6134 if (jj_3R_153()) {
6135 jj_scanpos = xsp;
6136 if (jj_3R_154()) {
6137 jj_scanpos = xsp;
6138 if (jj_3R_155()) {
6139 return true;
6140 }
6141 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6142 return false;
6143 }
6144 } else if (jj_la == 0
6145 && jj_scanpos == jj_lastpos) {
6146 return false;
6147 }
6148 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6149 return false;
6150 }
6151 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6152 return false;
6153 }
6154 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6155 return false;
6156 }
6157 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6158 return false;
6159 }
6160 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6161 return false;
6162 }
6163 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6164 return false;
6165 }
6166 return false;
6167 }
6168
6169 static final private boolean jj_3R_109() {
6170 if (jj_scan_token(LPAREN)) {
6171 return true;
6172 }
6173 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6174 return false;
6175 }
6176 if (jj_3R_47()) {
6177 return true;
6178 }
6179 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6180 return false;
6181 }
6182 if (jj_scan_token(LBRACKET)) {
6183 return true;
6184 }
6185 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6186 return false;
6187 }
6188 if (jj_scan_token(RBRACKET)) {
6189 return true;
6190 }
6191 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6192 return false;
6193 }
6194 return false;
6195 }
6196
6197 static final private boolean jj_3_16() {
6198 if (jj_scan_token(LPAREN)) {
6199 return true;
6200 }
6201 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6202 return false;
6203 }
6204 if (jj_3R_56()) {
6205 return true;
6206 }
6207 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6208 return false;
6209 }
6210 return false;
6211 }
6212
6213 static final private boolean jj_3R_55() {
6214 Token xsp;
6215
6216 xsp = jj_scanpos;
6217 if (jj_3_16()) {
6218 jj_scanpos = xsp;
6219 if (jj_3R_109()) {
6220 jj_scanpos = xsp;
6221 if (jj_3R_110()) {
6222 return true;
6223 }
6224 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6225 return false;
6226 }
6227 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6228 return false;
6229 }
6230 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6231 return false;
6232 }
6233 return false;
6234 }
6235
6236 static final private boolean jj_3_15() {
6237 if (jj_3R_55()) {
6238 return true;
6239 }
6240 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6241 return false;
6242 }
6243 return false;
6244 }
6245
6246 static final private boolean jj_3R_356() {
6247 if (jj_scan_token(BANG)) {
6248 return true;
6249 }
6250 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6251 return false;
6252 }
6253 return false;
6254 }
6255
6256 static final private boolean jj_3R_346() {
6257 if (jj_3R_358()) {
6258 return true;
6259 }
6260 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6261 return false;
6262 }
6263 return false;
6264 }
6265
6266 static final private boolean jj_3R_354() {
6267 if (jj_scan_token(REM)) {
6268 return true;
6269 }
6270 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6271 return false;
6272 }
6273 return false;
6274 }
6275
6276 static final private boolean jj_3R_355() {
6277 if (jj_scan_token(TILDE)) {
6278 return true;
6279 }
6280 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6281 return false;
6282 }
6283 return false;
6284 }
6285
6286 static final private boolean jj_3R_345() {
6287 if (jj_3R_357()) {
6288 return true;
6289 }
6290 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6291 return false;
6292 }
6293 return false;
6294 }
6295
6296 static final private boolean jj_3R_343() {
6297 if (jj_scan_token(MINUS)) {
6298 return true;
6299 }
6300 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6301 return false;
6302 }
6303 return false;
6304 }
6305
6306 static final private boolean jj_3R_344() {
6307 Token xsp;
6308
6309 xsp = jj_scanpos;
6310 if (jj_3R_355()) {
6311 jj_scanpos = xsp;
6312 if (jj_3R_356()) {
6313 return true;
6314 }
6315 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6316 return false;
6317 }
6318 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6319 return false;
6320 }
6321 if (jj_3R_262()) {
6322 return true;
6323 }
6324 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6325 return false;
6326 }
6327 return false;
6328 }
6329
6330 static final private boolean jj_3R_298() {
6331 Token xsp;
6332
6333 xsp = jj_scanpos;
6334 if (jj_3R_344()) {
6335 jj_scanpos = xsp;
6336 if (jj_3R_345()) {
6337 jj_scanpos = xsp;
6338 if (jj_3R_346()) {
6339 return true;
6340 }
6341 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6342 return false;
6343 }
6344 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6345 return false;
6346 }
6347 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6348 return false;
6349 }
6350 return false;
6351 }
6352
6353 static final private boolean jj_3R_353() {
6354 if (jj_scan_token(SLASH)) {
6355 return true;
6356 }
6357 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6358 return false;
6359 }
6360 return false;
6361 }
6362
6363 static final private boolean jj_3R_295() {
6364 if (jj_scan_token(RUNSIGNEDSHIFT)) {
6365 return true;
6366 }
6367 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6368 return false;
6369 }
6370 return false;
6371 }
6372
6373 static final private boolean jj_3R_342() {
6374 if (jj_scan_token(PLUS)) {
6375 return true;
6376 }
6377 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6378 return false;
6379 }
6380 return false;
6381 }
6382
6383 static final private boolean jj_3R_237() {
6384 if (jj_scan_token(DECR)) {
6385 return true;
6386 }
6387 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6388 return false;
6389 }
6390 if (jj_3R_53()) {
6391 return true;
6392 }
6393 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6394 return false;
6395 }
6396 return false;
6397 }
6398
6399 static final private boolean jj_3R_272() {
6400 if (jj_scan_token(GE)) {
6401 return true;
6402 }
6403 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6404 return false;
6405 }
6406 return false;
6407 }
6408
6409 static final private boolean jj_3R_292() {
6410 Token xsp;
6411
6412 xsp = jj_scanpos;
6413 if (jj_3R_342()) {
6414 jj_scanpos = xsp;
6415 if (jj_3R_343()) {
6416 return true;
6417 }
6418 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6419 return false;
6420 }
6421 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6422 return false;
6423 }
6424 if (jj_3R_255()) {
6425 return true;
6426 }
6427 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6428 return false;
6429 }
6430 return false;
6431 }
6432
6433 static final private boolean jj_3R_352() {
6434 if (jj_scan_token(STAR)) {
6435 return true;
6436 }
6437 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6438 return false;
6439 }
6440 return false;
6441 }
6442
6443 static final private boolean jj_3R_341() {
6444 Token xsp;
6445
6446 xsp = jj_scanpos;
6447 if (jj_3R_352()) {
6448 jj_scanpos = xsp;
6449 if (jj_3R_353()) {
6450 jj_scanpos = xsp;
6451 if (jj_3R_354()) {
6452 return true;
6453 }
6454 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6455 return false;
6456 }
6457 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6458 return false;
6459 }
6460 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6461 return false;
6462 }
6463 if (jj_3R_262()) {
6464 return true;
6465 }
6466 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6467 return false;
6468 }
6469 return false;
6470 }
6471
6472 static final private boolean jj_3R_294() {
6473 if (jj_scan_token(RSIGNEDSHIFT)) {
6474 return true;
6475 }
6476 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6477 return false;
6478 }
6479 return false;
6480 }
6481
6482 static final private boolean jj_3R_236() {
6483 if (jj_scan_token(INCR)) {
6484 return true;
6485 }
6486 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6487 return false;
6488 }
6489 if (jj_3R_53()) {
6490 return true;
6491 }
6492 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6493 return false;
6494 }
6495 return false;
6496 }
6497
6498 static final private boolean jj_3R_271() {
6499 if (jj_scan_token(LE)) {
6500 return true;
6501 }
6502 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6503 return false;
6504 }
6505 return false;
6506 }
6507
6508 static final private boolean jj_3R_297() {
6509 if (jj_scan_token(MINUS)) {
6510 return true;
6511 }
6512 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6513 return false;
6514 }
6515 return false;
6516 }
6517
6518 static final private boolean jj_3R_293() {
6519 if (jj_scan_token(LSHIFT)) {
6520 return true;
6521 }
6522 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6523 return false;
6524 }
6525 return false;
6526 }
6527
6528 static final private boolean jj_3R_276() {
6529 if (jj_3R_298()) {
6530 return true;
6531 }
6532 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6533 return false;
6534 }
6535 return false;
6536 }
6537
6538 static final private boolean jj_3R_268() {
6539 Token xsp;
6540
6541 xsp = jj_scanpos;
6542 if (jj_3R_293()) {
6543 jj_scanpos = xsp;
6544 if (jj_3R_294()) {
6545 jj_scanpos = xsp;
6546 if (jj_3R_295()) {
6547 return true;
6548 }
6549 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6550 return false;
6551 }
6552 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6553 return false;
6554 }
6555 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6556 return false;
6557 }
6558 if (jj_3R_250()) {
6559 return true;
6560 }
6561 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6562 return false;
6563 }
6564 return false;
6565 }
6566
6567 static final private boolean jj_3R_270() {
6568 if (jj_scan_token(GT)) {
6569 return true;
6570 }
6571 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6572 return false;
6573 }
6574 return false;
6575 }
6576
6577 static final private boolean jj_3R_275() {
6578 if (jj_3R_237()) {
6579 return true;
6580 }
6581 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6582 return false;
6583 }
6584 return false;
6585 }
6586
6587 static final private boolean jj_3R_211() {
6588 if (jj_scan_token(ORASSIGN)) {
6589 return true;
6590 }
6591 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6592 return false;
6593 }
6594 return false;
6595 }
6596
6597 static final private boolean jj_3R_274() {
6598 if (jj_3R_236()) {
6599 return true;
6600 }
6601 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6602 return false;
6603 }
6604 return false;
6605 }
6606
6607 static final private boolean jj_3R_296() {
6608 if (jj_scan_token(PLUS)) {
6609 return true;
6610 }
6611 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6612 return false;
6613 }
6614 return false;
6615 }
6616
6617 static final private boolean jj_3R_262() {
6618 Token xsp;
6619
6620 xsp = jj_scanpos;
6621 if (jj_3R_273()) {
6622 jj_scanpos = xsp;
6623 if (jj_3R_274()) {
6624 jj_scanpos = xsp;
6625 if (jj_3R_275()) {
6626 jj_scanpos = xsp;
6627 if (jj_3R_276()) {
6628 return true;
6629 }
6630 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6631 return false;
6632 }
6633 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6634 return false;
6635 }
6636 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6637 return false;
6638 }
6639 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6640 return false;
6641 }
6642 return false;
6643 }
6644
6645 static final private boolean jj_3R_273() {
6646 Token xsp;
6647
6648 xsp = jj_scanpos;
6649 if (jj_3R_296()) {
6650 jj_scanpos = xsp;
6651 if (jj_3R_297()) {
6652 return true;
6653 }
6654 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6655 return false;
6656 }
6657 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6658 return false;
6659 }
6660 if (jj_3R_262()) {
6661 return true;
6662 }
6663 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6664 return false;
6665 }
6666 return false;
6667 }
6668
6669 static final private boolean jj_3R_254() {
6670 if (jj_scan_token(NE)) {
6671 return true;
6672 }
6673 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6674 return false;
6675 }
6676 return false;
6677 }
6678
6679 static final private boolean jj_3R_269() {
6680 if (jj_scan_token(LT)) {
6681 return true;
6682 }
6683 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6684 return false;
6685 }
6686 return false;
6687 }
6688
6689 static final private boolean jj_3R_261() {
6690 Token xsp;
6691
6692 xsp = jj_scanpos;
6693 if (jj_3R_269()) {
6694 jj_scanpos = xsp;
6695 if (jj_3R_270()) {
6696 jj_scanpos = xsp;
6697 if (jj_3R_271()) {
6698 jj_scanpos = xsp;
6699 if (jj_3R_272()) {
6700 return true;
6701 }
6702 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6703 return false;
6704 }
6705 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6706 return false;
6707 }
6708 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6709 return false;
6710 }
6711 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6712 return false;
6713 }
6714 if (jj_3R_245()) {
6715 return true;
6716 }
6717 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6718 return false;
6719 }
6720 return false;
6721 }
6722
6723 static final private boolean jj_3R_210() {
6724 if (jj_scan_token(XORASSIGN)) {
6725 return true;
6726 }
6727 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6728 return false;
6729 }
6730 return false;
6731 }
6732
6733 static final private boolean jj_3R_252() {
6734 if (jj_scan_token(INSTANCEOF)) {
6735 return true;
6736 }
6737 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6738 return false;
6739 }
6740 if (jj_3R_63()) {
6741 return true;
6742 }
6743 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6744 return false;
6745 }
6746 return false;
6747 }
6748
6749 static final private boolean jj_3R_255() {
6750 if (jj_3R_262()) {
6751 return true;
6752 }
6753 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6754 return false;
6755 }
6756 Token xsp;
6757
6758 while (true) {
6759 xsp = jj_scanpos;
6760 if (jj_3R_341()) {
6761 jj_scanpos = xsp;
6762 break;
6763 }
6764 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6765 return false;
6766 }
6767 }
6768 return false;
6769 }
6770
6771 static final private boolean jj_3R_253() {
6772 if (jj_scan_token(EQ)) {
6773 return true;
6774 }
6775 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6776 return false;
6777 }
6778 return false;
6779 }
6780
6781 static final private boolean jj_3R_249() {
6782 Token xsp;
6783
6784 xsp = jj_scanpos;
6785 if (jj_3R_253()) {
6786 jj_scanpos = xsp;
6787 if (jj_3R_254()) {
6788 return true;
6789 }
6790 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6791 return false;
6792 }
6793 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6794 return false;
6795 }
6796 if (jj_3R_235()) {
6797 return true;
6798 }
6799 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6800 return false;
6801 }
6802 return false;
6803 }
6804
6805 static final private boolean jj_3R_209() {
6806 if (jj_scan_token(ANDASSIGN)) {
6807 return true;
6808 }
6809 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6810 return false;
6811 }
6812 return false;
6813 }
6814
6815 static final private boolean jj_3R_250() {
6816 if (jj_3R_255()) {
6817 return true;
6818 }
6819 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6820 return false;
6821 }
6822 Token xsp;
6823
6824 while (true) {
6825 xsp = jj_scanpos;
6826 if (jj_3R_292()) {
6827 jj_scanpos = xsp;
6828 break;
6829 }
6830 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6831 return false;
6832 }
6833 }
6834 return false;
6835 }
6836
6837 static final private boolean jj_3R_245() {
6838 if (jj_3R_250()) {
6839 return true;
6840 }
6841 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6842 return false;
6843 }
6844 Token xsp;
6845
6846 while (true) {
6847 xsp = jj_scanpos;
6848 if (jj_3R_268()) {
6849 jj_scanpos = xsp;
6850 break;
6851 }
6852 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6853 return false;
6854 }
6855 }
6856 return false;
6857 }
6858
6859 static final private boolean jj_3R_244() {
6860 if (jj_scan_token(BIT_AND)) {
6861 return true;
6862 }
6863 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6864 return false;
6865 }
6866 if (jj_3R_227()) {
6867 return true;
6868 }
6869 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6870 return false;
6871 }
6872 return false;
6873 }
6874
6875 static final private boolean jj_3R_208() {
6876 if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) {
6877 return true;
6878 }
6879 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6880 return false;
6881 }
6882 return false;
6883 }
6884
6885 static final private boolean jj_3R_241() {
6886 if (jj_3R_245()) {
6887 return true;
6888 }
6889 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6890 return false;
6891 }
6892 Token xsp;
6893
6894 while (true) {
6895 xsp = jj_scanpos;
6896 if (jj_3R_261()) {
6897 jj_scanpos = xsp;
6898 break;
6899 }
6900 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6901 return false;
6902 }
6903 }
6904 return false;
6905 }
6906
6907 static final private boolean jj_3R_234() {
6908 if (jj_scan_token(BIT_OR)) {
6909 return true;
6910 }
6911 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6912 return false;
6913 }
6914 if (jj_3R_181()) {
6915 return true;
6916 }
6917 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6918 return false;
6919 }
6920 return false;
6921 }
6922
6923 static final private boolean jj_3R_207() {
6924 if (jj_scan_token(RSIGNEDSHIFTASSIGN)) {
6925 return true;
6926 }
6927 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6928 return false;
6929 }
6930 return false;
6931 }
6932
6933 static final private boolean jj_3R_235() {
6934 if (jj_3R_241()) {
6935 return true;
6936 }
6937 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6938 return false;
6939 }
6940 Token xsp;
6941
6942 xsp = jj_scanpos;
6943 if (jj_3R_252()) {
6944 jj_scanpos = xsp;
6945 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6946 return false;
6947 }
6948 return false;
6949 }
6950
6951 static final private boolean jj_3R_240() {
6952 if (jj_scan_token(XOR)) {
6953 return true;
6954 }
6955 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6956 return false;
6957 }
6958 if (jj_3R_212()) {
6959 return true;
6960 }
6961 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6962 return false;
6963 }
6964 return false;
6965 }
6966
6967 static final private boolean jj_3R_226() {
6968 if (jj_scan_token(SC_AND)) {
6969 return true;
6970 }
6971 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6972 return false;
6973 }
6974 if (jj_3R_172()) {
6975 return true;
6976 }
6977 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6978 return false;
6979 }
6980 return false;
6981 }
6982
6983 static final private boolean jj_3R_227() {
6984 if (jj_3R_235()) {
6985 return true;
6986 }
6987 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6988 return false;
6989 }
6990 Token xsp;
6991
6992 while (true) {
6993 xsp = jj_scanpos;
6994 if (jj_3R_249()) {
6995 jj_scanpos = xsp;
6996 break;
6997 }
6998 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
6999 return false;
7000 }
7001 }
7002 return false;
7003 }
7004
7005 static final private boolean jj_3R_199() {
7006 if (jj_scan_token(SC_OR)) {
7007 return true;
7008 }
7009 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7010 return false;
7011 }
7012 if (jj_3R_160()) {
7013 return true;
7014 }
7015 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7016 return false;
7017 }
7018 return false;
7019 }
7020
7021 static final private boolean jj_3R_206() {
7022 if (jj_scan_token(LSHIFTASSIGN)) {
7023 return true;
7024 }
7025 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7026 return false;
7027 }
7028 return false;
7029 }
7030
7031 static final private boolean jj_3R_212() {
7032 if (jj_3R_227()) {
7033 return true;
7034 }
7035 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7036 return false;
7037 }
7038 Token xsp;
7039
7040 while (true) {
7041 xsp = jj_scanpos;
7042 if (jj_3R_244()) {
7043 jj_scanpos = xsp;
7044 break;
7045 }
7046 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7047 return false;
7048 }
7049 }
7050 return false;
7051 }
7052
7053 static final private boolean jj_3R_179() {
7054 if (jj_scan_token(HOOK)) {
7055 return true;
7056 }
7057 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7058 return false;
7059 }
7060 if (jj_3R_60()) {
7061 return true;
7062 }
7063 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7064 return false;
7065 }
7066 if (jj_scan_token(COLON)) {
7067 return true;
7068 }
7069 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7070 return false;
7071 }
7072 if (jj_3R_125()) {
7073 return true;
7074 }
7075 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7076 return false;
7077 }
7078 return false;
7079 }
7080
7081 static final private boolean jj_3R_205() {
7082 if (jj_scan_token(MINUSASSIGN)) {
7083 return true;
7084 }
7085 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7086 return false;
7087 }
7088 return false;
7089 }
7090
7091 static final private boolean jj_3R_181() {
7092 if (jj_3R_212()) {
7093 return true;
7094 }
7095 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7096 return false;
7097 }
7098 Token xsp;
7099
7100 while (true) {
7101 xsp = jj_scanpos;
7102 if (jj_3R_240()) {
7103 jj_scanpos = xsp;
7104 break;
7105 }
7106 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7107 return false;
7108 }
7109 }
7110 return false;
7111 }
7112
7113 static final private boolean jj_3R_204() {
7114 if (jj_scan_token(PLUSASSIGN)) {
7115 return true;
7116 }
7117 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7118 return false;
7119 }
7120 return false;
7121 }
7122
7123 static final private boolean jj_3R_172() {
7124 if (jj_3R_181()) {
7125 return true;
7126 }
7127 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7128 return false;
7129 }
7130 Token xsp;
7131
7132 while (true) {
7133 xsp = jj_scanpos;
7134 if (jj_3R_234()) {
7135 jj_scanpos = xsp;
7136 break;
7137 }
7138 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7139 return false;
7140 }
7141 }
7142 return false;
7143 }
7144
7145 static final private boolean jj_3R_203() {
7146 if (jj_scan_token(REMASSIGN)) {
7147 return true;
7148 }
7149 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7150 return false;
7151 }
7152 return false;
7153 }
7154
7155 static final private boolean jj_3R_160() {
7156 if (jj_3R_172()) {
7157 return true;
7158 }
7159 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7160 return false;
7161 }
7162 Token xsp;
7163
7164 while (true) {
7165 xsp = jj_scanpos;
7166 if (jj_3R_226()) {
7167 jj_scanpos = xsp;
7168 break;
7169 }
7170 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7171 return false;
7172 }
7173 }
7174 return false;
7175 }
7176
7177 static final private boolean jj_3R_202() {
7178 if (jj_scan_token(SLASHASSIGN)) {
7179 return true;
7180 }
7181 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7182 return false;
7183 }
7184 return false;
7185 }
7186
7187 static final private boolean jj_3R_156() {
7188 if (jj_3R_160()) {
7189 return true;
7190 }
7191 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7192 return false;
7193 }
7194 Token xsp;
7195
7196 while (true) {
7197 xsp = jj_scanpos;
7198 if (jj_3R_199()) {
7199 jj_scanpos = xsp;
7200 break;
7201 }
7202 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7203 return false;
7204 }
7205 }
7206 return false;
7207 }
7208
7209 static final private boolean jj_3R_125() {
7210 if (jj_3R_156()) {
7211 return true;
7212 }
7213 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7214 return false;
7215 }
7216 Token xsp;
7217
7218 xsp = jj_scanpos;
7219 if (jj_3R_179()) {
7220 jj_scanpos = xsp;
7221 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7222 return false;
7223 }
7224 return false;
7225 }
7226
7227 static final private boolean jj_3R_201() {
7228 if (jj_scan_token(STARASSIGN)) {
7229 return true;
7230 }
7231 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7232 return false;
7233 }
7234 return false;
7235 }
7236
7237 static final private boolean jj_3R_180() {
7238 Token xsp;
7239
7240 xsp = jj_scanpos;
7241 if (jj_3R_200()) {
7242 jj_scanpos = xsp;
7243 if (jj_3R_201()) {
7244 jj_scanpos = xsp;
7245 if (jj_3R_202()) {
7246 jj_scanpos = xsp;
7247 if (jj_3R_203()) {
7248 jj_scanpos = xsp;
7249 if (jj_3R_204()) {
7250 jj_scanpos = xsp;
7251 if (jj_3R_205()) {
7252 jj_scanpos = xsp;
7253 if (jj_3R_206()) {
7254 jj_scanpos = xsp;
7255 if (jj_3R_207()) {
7256 jj_scanpos = xsp;
7257 if (jj_3R_208()) {
7258 jj_scanpos = xsp;
7259 if (jj_3R_209()) {
7260 jj_scanpos = xsp;
7261 if (jj_3R_210()) {
7262 jj_scanpos = xsp;
7263 if (jj_3R_211()) {
7264 return true;
7265 }
7266 if (jj_la == 0
7267 && jj_scanpos
7268 == jj_lastpos) {
7269 return false;
7270 }
7271 } else if (jj_la == 0
7272 && jj_scanpos
7273 == jj_lastpos) {
7274 return false;
7275 }
7276 } else if (jj_la == 0
7277 && jj_scanpos == jj_lastpos) {
7278 return false;
7279 }
7280 } else if (jj_la == 0
7281 && jj_scanpos == jj_lastpos) {
7282 return false;
7283 }
7284 } else if (jj_la == 0
7285 && jj_scanpos == jj_lastpos) {
7286 return false;
7287 }
7288 } else if (jj_la == 0
7289 && jj_scanpos == jj_lastpos) {
7290 return false;
7291 }
7292 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7293 return false;
7294 }
7295 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7296 return false;
7297 }
7298 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7299 return false;
7300 }
7301 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7302 return false;
7303 }
7304 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7305 return false;
7306 }
7307 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7308 return false;
7309 }
7310 return false;
7311 }
7312
7313 static final private boolean jj_3R_200() {
7314 if (jj_scan_token(ASSIGN)) {
7315 return true;
7316 }
7317 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7318 return false;
7319 }
7320 return false;
7321 }
7322
7323 static final private boolean jj_3R_171() {
7324 if (jj_3R_180()) {
7325 return true;
7326 }
7327 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7328 return false;
7329 }
7330 if (jj_3R_60()) {
7331 return true;
7332 }
7333 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7334 return false;
7335 }
7336 return false;
7337 }
7338
7339 static final private boolean jj_3R_60() {
7340 if (jj_3R_125()) {
7341 return true;
7342 }
7343 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7344 return false;
7345 }
7346 Token xsp;
7347
7348 xsp = jj_scanpos;
7349 if (jj_3R_171()) {
7350 jj_scanpos = xsp;
7351 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7352 return false;
7353 }
7354 return false;
7355 }
7356
7357 static final private boolean jj_3R_350() {
7358 if (jj_scan_token(COMMA)) {
7359 return true;
7360 }
7361 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7362 return false;
7363 }
7364 if (jj_3R_47()) {
7365 return true;
7366 }
7367 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7368 return false;
7369 }
7370 return false;
7371 }
7372
7373 static final private boolean jj_3R_321() {
7374 if (jj_3R_47()) {
7375 return true;
7376 }
7377 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7378 return false;
7379 }
7380 Token xsp;
7381
7382 while (true) {
7383 xsp = jj_scanpos;
7384 if (jj_3R_350()) {
7385 jj_scanpos = xsp;
7386 break;
7387 }
7388 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7389 return false;
7390 }
7391 }
7392 return false;
7393 }
7394
7395 static final private boolean jj_3R_330() {
7396 if (jj_scan_token(STRICTFP)) {
7397 return true;
7398 }
7399 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7400 return false;
7401 }
7402 return false;
7403 }
7404
7405 static final private boolean jj_3_14() {
7406 if (jj_scan_token(DOT)) {
7407 return true;
7408 }
7409 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7410 return false;
7411 }
7412 if (jj_scan_token(IDENTIFIER)) {
7413 return true;
7414 }
7415 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7416 return false;
7417 }
7418 return false;
7419 }
7420
7421 static final private boolean jj_3R_47() {
7422 if (jj_scan_token(IDENTIFIER)) {
7423 return true;
7424 }
7425 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7426 return false;
7427 }
7428 Token xsp;
7429
7430 while (true) {
7431 xsp = jj_scanpos;
7432 if (jj_3_14()) {
7433 jj_scanpos = xsp;
7434 break;
7435 }
7436 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7437 return false;
7438 }
7439 }
7440 return false;
7441 }
7442
7443 static final private boolean jj_3R_128() {
7444 if (jj_scan_token(LBRACKET)) {
7445 return true;
7446 }
7447 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7448 return false;
7449 }
7450 if (jj_scan_token(RBRACKET)) {
7451 return true;
7452 }
7453 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7454 return false;
7455 }
7456 return false;
7457 }
7458
7459 static final private boolean jj_3R_123() {
7460 if (jj_3R_63()) {
7461 return true;
7462 }
7463 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7464 return false;
7465 }
7466 return false;
7467 }
7468
7469 static final private boolean jj_3R_329() {
7470 if (jj_scan_token(SYNCHRONIZED)) {
7471 return true;
7472 }
7473 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7474 return false;
7475 }
7476 return false;
7477 }
7478
7479 static final private boolean jj_3R_122() {
7480 if (jj_scan_token(VOID)) {
7481 return true;
7482 }
7483 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7484 return false;
7485 }
7486 return false;
7487 }
7488
7489 static final private boolean jj_3R_58() {
7490 Token xsp;
7491
7492 xsp = jj_scanpos;
7493 if (jj_3R_122()) {
7494 jj_scanpos = xsp;
7495 if (jj_3R_123()) {
7496 return true;
7497 }
7498 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7499 return false;
7500 }
7501 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7502 return false;
7503 }
7504 return false;
7505 }
7506
7507 static final private boolean jj_3R_127() {
7508 if (jj_3R_47()) {
7509 return true;
7510 }
7511 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7512 return false;
7513 }
7514 return false;
7515 }
7516
7517 static final private boolean jj_3R_118() {
7518 if (jj_scan_token(DOUBLE)) {
7519 return true;
7520 }
7521 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7522 return false;
7523 }
7524 return false;
7525 }
7526
7527 static final private boolean jj_3R_117() {
7528 if (jj_scan_token(FLOAT)) {
7529 return true;
7530 }
7531 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7532 return false;
7533 }
7534 return false;
7535 }
7536
7537 static final private boolean jj_3R_328() {
7538 if (jj_scan_token(NATIVE)) {
7539 return true;
7540 }
7541 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7542 return false;
7543 }
7544 return false;
7545 }
7546
7547 static final private boolean jj_3R_116() {
7548 if (jj_scan_token(LONG)) {
7549 return true;
7550 }
7551 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7552 return false;
7553 }
7554 return false;
7555 }
7556
7557 static final private boolean jj_3R_115() {
7558 if (jj_scan_token(INT)) {
7559 return true;
7560 }
7561 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7562 return false;
7563 }
7564 return false;
7565 }
7566
7567 static final private boolean jj_3R_247() {
7568 if (jj_scan_token(COMMA)) {
7569 return true;
7570 }
7571 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7572 return false;
7573 }
7574 return false;
7575 }
7576
7577 static final private boolean jj_3R_114() {
7578 if (jj_scan_token(SHORT)) {
7579 return true;
7580 }
7581 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7582 return false;
7583 }
7584 return false;
7585 }
7586
7587 static final private boolean jj_3R_113() {
7588 if (jj_scan_token(BYTE)) {
7589 return true;
7590 }
7591 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7592 return false;
7593 }
7594 return false;
7595 }
7596
7597 static final private boolean jj_3R_112() {
7598 if (jj_scan_token(CHAR)) {
7599 return true;
7600 }
7601 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7602 return false;
7603 }
7604 return false;
7605 }
7606
7607 static final private boolean jj_3R_327() {
7608 if (jj_scan_token(FINAL)) {
7609 return true;
7610 }
7611 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7612 return false;
7613 }
7614 return false;
7615 }
7616
7617 static final private boolean jj_3R_111() {
7618 if (jj_scan_token(BOOLEAN)) {
7619 return true;
7620 }
7621 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7622 return false;
7623 }
7624 return false;
7625 }
7626
7627 static final private boolean jj_3R_56() {
7628 Token xsp;
7629
7630 xsp = jj_scanpos;
7631 if (jj_3R_111()) {
7632 jj_scanpos = xsp;
7633 if (jj_3R_112()) {
7634 jj_scanpos = xsp;
7635 if (jj_3R_113()) {
7636 jj_scanpos = xsp;
7637 if (jj_3R_114()) {
7638 jj_scanpos = xsp;
7639 if (jj_3R_115()) {
7640 jj_scanpos = xsp;
7641 if (jj_3R_116()) {
7642 jj_scanpos = xsp;
7643 if (jj_3R_117()) {
7644 jj_scanpos = xsp;
7645 if (jj_3R_118()) {
7646 return true;
7647 }
7648 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7649 return false;
7650 }
7651 } else if (jj_la == 0
7652 && jj_scanpos == jj_lastpos) {
7653 return false;
7654 }
7655 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7656 return false;
7657 }
7658 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7659 return false;
7660 }
7661 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7662 return false;
7663 }
7664 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7665 return false;
7666 }
7667 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7668 return false;
7669 }
7670 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7671 return false;
7672 }
7673 return false;
7674 }
7675
7676 static final private boolean jj_3R_281() {
7677 if (jj_scan_token(THROWS)) {
7678 return true;
7679 }
7680 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7681 return false;
7682 }
7683 if (jj_3R_321()) {
7684 return true;
7685 }
7686 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7687 return false;
7688 }
7689 return false;
7690 }
7691
7692 static final private boolean jj_3R_126() {
7693 if (jj_3R_56()) {
7694 return true;
7695 }
7696 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7697 return false;
7698 }
7699 return false;
7700 }
7701
7702 static final private boolean jj_3R_63() {
7703 Token xsp;
7704
7705 xsp = jj_scanpos;
7706 if (jj_3R_126()) {
7707 jj_scanpos = xsp;
7708 if (jj_3R_127()) {
7709 return true;
7710 }
7711 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7712 return false;
7713 }
7714 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7715 return false;
7716 }
7717 while (true) {
7718 xsp = jj_scanpos;
7719 if (jj_3R_128()) {
7720 jj_scanpos = xsp;
7721 break;
7722 }
7723 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7724 return false;
7725 }
7726 }
7727 return false;
7728 }
7729
7730 static final private boolean jj_3R_319() {
7731 if (jj_scan_token(PRIVATE)) {
7732 return true;
7733 }
7734 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7735 return false;
7736 }
7737 return false;
7738 }
7739
7740 static final private boolean jj_3R_326() {
7741 if (jj_scan_token(ABSTRACT)) {
7742 return true;
7743 }
7744 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7745 return false;
7746 }
7747 return false;
7748 }
7749
7750 static final private boolean jj_3R_69() {
7751 if (jj_scan_token(STATIC)) {
7752 return true;
7753 }
7754 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7755 return false;
7756 }
7757 return false;
7758 }
7759
7760 static final private boolean jj_3_13() {
7761 if (jj_scan_token(THIS)) {
7762 return true;
7763 }
7764 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7765 return false;
7766 }
7767 if (jj_3R_54()) {
7768 return true;
7769 }
7770 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7771 return false;
7772 }
7773 if (jj_scan_token(SEMICOLON)) {
7774 return true;
7775 }
7776 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7777 return false;
7778 }
7779 return false;
7780 }
7781
7782 static final private boolean jj_3R_43() {
7783 Token xsp;
7784
7785 xsp = jj_scanpos;
7786 if (jj_3R_69()) {
7787 jj_scanpos = xsp;
7788 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7789 return false;
7790 }
7791 if (jj_3R_70()) {
7792 return true;
7793 }
7794 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7795 return false;
7796 }
7797 return false;
7798 }
7799
7800 static final private boolean jj_3_11() {
7801 if (jj_3R_52()) {
7802 return true;
7803 }
7804 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7805 return false;
7806 }
7807 return false;
7808 }
7809
7810 static final private boolean jj_3R_331() {
7811 if (jj_scan_token(LBRACKET)) {
7812 return true;
7813 }
7814 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7815 return false;
7816 }
7817 if (jj_scan_token(RBRACKET)) {
7818 return true;
7819 }
7820 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7821 return false;
7822 }
7823 return false;
7824 }
7825
7826 static final private boolean jj_3_12() {
7827 if (jj_3R_53()) {
7828 return true;
7829 }
7830 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7831 return false;
7832 }
7833 if (jj_scan_token(DOT)) {
7834 return true;
7835 }
7836 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7837 return false;
7838 }
7839 return false;
7840 }
7841
7842 static final private boolean jj_3R_338() {
7843 if (jj_scan_token(VOLATILE)) {
7844 return true;
7845 }
7846 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7847 return false;
7848 }
7849 return false;
7850 }
7851
7852 static final private boolean jj_3R_349() {
7853 if (jj_scan_token(COMMA)) {
7854 return true;
7855 }
7856 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7857 return false;
7858 }
7859 if (jj_3R_348()) {
7860 return true;
7861 }
7862 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7863 return false;
7864 }
7865 return false;
7866 }
7867
7868 static final private boolean jj_3R_106() {
7869 Token xsp;
7870
7871 xsp = jj_scanpos;
7872 if (jj_3_12()) {
7873 jj_scanpos = xsp;
7874 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7875 return false;
7876 }
7877 if (jj_scan_token(SUPER)) {
7878 return true;
7879 }
7880 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7881 return false;
7882 }
7883 if (jj_3R_54()) {
7884 return true;
7885 }
7886 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7887 return false;
7888 }
7889 if (jj_scan_token(SEMICOLON)) {
7890 return true;
7891 }
7892 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7893 return false;
7894 }
7895 return false;
7896 }
7897
7898 static final private boolean jj_3R_325() {
7899 if (jj_scan_token(STATIC)) {
7900 return true;
7901 }
7902 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7903 return false;
7904 }
7905 return false;
7906 }
7907
7908 static final private boolean jj_3R_318() {
7909 if (jj_scan_token(PROTECTED)) {
7910 return true;
7911 }
7912 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7913 return false;
7914 }
7915 return false;
7916 }
7917
7918 static final private boolean jj_3R_102() {
7919 if (jj_scan_token(STRICTFP)) {
7920 return true;
7921 }
7922 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7923 return false;
7924 }
7925 return false;
7926 }
7927
7928 static final private boolean jj_3R_105() {
7929 if (jj_scan_token(THIS)) {
7930 return true;
7931 }
7932 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7933 return false;
7934 }
7935 if (jj_3R_54()) {
7936 return true;
7937 }
7938 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7939 return false;
7940 }
7941 if (jj_scan_token(SEMICOLON)) {
7942 return true;
7943 }
7944 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7945 return false;
7946 }
7947 return false;
7948 }
7949
7950 static final private boolean jj_3R_52() {
7951 Token xsp;
7952
7953 xsp = jj_scanpos;
7954 if (jj_3R_105()) {
7955 jj_scanpos = xsp;
7956 if (jj_3R_106()) {
7957 return true;
7958 }
7959 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7960 return false;
7961 }
7962 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7963 return false;
7964 }
7965 return false;
7966 }
7967
7968 static final private boolean jj_3R_95() {
7969 if (jj_scan_token(STRICTFP)) {
7970 return true;
7971 }
7972 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7973 return false;
7974 }
7975 return false;
7976 }
7977
7978 static final private boolean jj_3R_286() {
7979 if (jj_scan_token(THROWS)) {
7980 return true;
7981 }
7982 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7983 return false;
7984 }
7985 if (jj_3R_321()) {
7986 return true;
7987 }
7988 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7989 return false;
7990 }
7991 return false;
7992 }
7993
7994 static final private boolean jj_3R_283() {
7995 if (jj_3R_157()) {
7996 return true;
7997 }
7998 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
7999 return false;
8000 }
8001 return false;
8002 }
8003
8004 static final private boolean jj_3R_282() {
8005 if (jj_3R_52()) {
8006 return true;
8007 }
8008 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8009 return false;
8010 }
8011 return false;
8012 }
8013
8014 static final private boolean jj_3R_317() {
8015 if (jj_scan_token(PUBLIC)) {
8016 return true;
8017 }
8018 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8019 return false;
8020 }
8021 return false;
8022 }
8023
8024 static final private boolean jj_3R_279() {
8025 Token xsp;
8026
8027 xsp = jj_scanpos;
8028 if (jj_3R_317()) {
8029 jj_scanpos = xsp;
8030 if (jj_3R_318()) {
8031 jj_scanpos = xsp;
8032 if (jj_3R_319()) {
8033 return true;
8034 }
8035 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8036 return false;
8037 }
8038 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8039 return false;
8040 }
8041 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8042 return false;
8043 }
8044 return false;
8045 }
8046
8047 static final private boolean jj_3R_337() {
8048 if (jj_scan_token(TRANSIENT)) {
8049 return true;
8050 }
8051 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8052 return false;
8053 }
8054 return false;
8055 }
8056
8057 static final private boolean jj_3R_324() {
8058 if (jj_scan_token(PRIVATE)) {
8059 return true;
8060 }
8061 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8062 return false;
8063 }
8064 return false;
8065 }
8066
8067 static final private boolean jj_3R_101() {
8068 if (jj_scan_token(PRIVATE)) {
8069 return true;
8070 }
8071 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8072 return false;
8073 }
8074 return false;
8075 }
8076
8077 static final private boolean jj_3R_265() {
8078 Token xsp;
8079
8080 xsp = jj_scanpos;
8081 if (jj_3R_279()) {
8082 jj_scanpos = xsp;
8083 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8084 return false;
8085 }
8086 if (jj_scan_token(IDENTIFIER)) {
8087 return true;
8088 }
8089 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8090 return false;
8091 }
8092 if (jj_3R_280()) {
8093 return true;
8094 }
8095 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8096 return false;
8097 }
8098 xsp = jj_scanpos;
8099 if (jj_3R_281()) {
8100 jj_scanpos = xsp;
8101 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8102 return false;
8103 }
8104 if (jj_scan_token(LBRACE)) {
8105 return true;
8106 }
8107 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8108 return false;
8109 }
8110 xsp = jj_scanpos;
8111 if (jj_3R_282()) {
8112 jj_scanpos = xsp;
8113 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8114 return false;
8115 }
8116 while (true) {
8117 xsp = jj_scanpos;
8118 if (jj_3R_283()) {
8119 jj_scanpos = xsp;
8120 break;
8121 }
8122 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8123 return false;
8124 }
8125 }
8126 if (jj_scan_token(RBRACE)) {
8127 return true;
8128 }
8129 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8130 return false;
8131 }
8132 return false;
8133 }
8134
8135 static final private boolean jj_3R_138() {
8136 if (jj_scan_token(STRICTFP)) {
8137 return true;
8138 }
8139 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8140 return false;
8141 }
8142 return false;
8143 }
8144
8145 static final private boolean jj_3R_94() {
8146 if (jj_scan_token(PRIVATE)) {
8147 return true;
8148 }
8149 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8150 return false;
8151 }
8152 return false;
8153 }
8154
8155 static final private boolean jj_3_10() {
8156 if (jj_scan_token(COMMA)) {
8157 return true;
8158 }
8159 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8160 return false;
8161 }
8162 if (jj_3R_51()) {
8163 return true;
8164 }
8165 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8166 return false;
8167 }
8168 return false;
8169 }
8170
8171 static final private boolean jj_3R_363() {
8172 if (jj_scan_token(FINAL)) {
8173 return true;
8174 }
8175 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8176 return false;
8177 }
8178 return false;
8179 }
8180
8181 static final private boolean jj_3R_348() {
8182 Token xsp;
8183
8184 xsp = jj_scanpos;
8185 if (jj_3R_363()) {
8186 jj_scanpos = xsp;
8187 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8188 return false;
8189 }
8190 if (jj_3R_63()) {
8191 return true;
8192 }
8193 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8194 return false;
8195 }
8196 if (jj_3R_339()) {
8197 return true;
8198 }
8199 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8200 return false;
8201 }
8202 return false;
8203 }
8204
8205 static final private boolean jj_3R_320() {
8206 if (jj_3R_348()) {
8207 return true;
8208 }
8209 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8210 return false;
8211 }
8212 Token xsp;
8213
8214 while (true) {
8215 xsp = jj_scanpos;
8216 if (jj_3R_349()) {
8217 jj_scanpos = xsp;
8218 break;
8219 }
8220 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8221 return false;
8222 }
8223 }
8224 return false;
8225 }
8226
8227 static final private boolean jj_3R_336() {
8228 if (jj_scan_token(FINAL)) {
8229 return true;
8230 }
8231 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8232 return false;
8233 }
8234 return false;
8235 }
8236
8237 static final private boolean jj_3R_280() {
8238 if (jj_scan_token(LPAREN)) {
8239 return true;
8240 }
8241 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8242 return false;
8243 }
8244 Token xsp;
8245
8246 xsp = jj_scanpos;
8247 if (jj_3R_320()) {
8248 jj_scanpos = xsp;
8249 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8250 return false;
8251 }
8252 if (jj_scan_token(RPAREN)) {
8253 return true;
8254 }
8255 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8256 return false;
8257 }
8258 return false;
8259 }
8260
8261 static final private boolean jj_3R_288() {
8262 if (jj_scan_token(SEMICOLON)) {
8263 return true;
8264 }
8265 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8266 return false;
8267 }
8268 return false;
8269 }
8270
8271 static final private boolean jj_3R_323() {
8272 if (jj_scan_token(PROTECTED)) {
8273 return true;
8274 }
8275 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8276 return false;
8277 }
8278 return false;
8279 }
8280
8281 static final private boolean jj_3R_100() {
8282 if (jj_scan_token(PROTECTED)) {
8283 return true;
8284 }
8285 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8286 return false;
8287 }
8288 return false;
8289 }
8290
8291 static final private boolean jj_3R_314() {
8292 if (jj_scan_token(STRICTFP)) {
8293 return true;
8294 }
8295 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8296 return false;
8297 }
8298 return false;
8299 }
8300
8301 static final private boolean jj_3R_93() {
8302 if (jj_scan_token(PROTECTED)) {
8303 return true;
8304 }
8305 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8306 return false;
8307 }
8308 return false;
8309 }
8310
8311 static final private boolean jj_3R_137() {
8312 if (jj_scan_token(SYNCHRONIZED)) {
8313 return true;
8314 }
8315 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8316 return false;
8317 }
8318 return false;
8319 }
8320
8321 static final private boolean jj_3R_285() {
8322 if (jj_scan_token(IDENTIFIER)) {
8323 return true;
8324 }
8325 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8326 return false;
8327 }
8328 if (jj_3R_280()) {
8329 return true;
8330 }
8331 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8332 return false;
8333 }
8334 Token xsp;
8335
8336 while (true) {
8337 xsp = jj_scanpos;
8338 if (jj_3R_331()) {
8339 jj_scanpos = xsp;
8340 break;
8341 }
8342 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8343 return false;
8344 }
8345 }
8346 return false;
8347 }
8348
8349 static final private boolean jj_3R_335() {
8350 if (jj_scan_token(STATIC)) {
8351 return true;
8352 }
8353 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8354 return false;
8355 }
8356 return false;
8357 }
8358
8359 static final private boolean jj_3R_287() {
8360 if (jj_3R_70()) {
8361 return true;
8362 }
8363 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8364 return false;
8365 }
8366 return false;
8367 }
8368
8369 static final private boolean jj_3R_322() {
8370 if (jj_scan_token(PUBLIC)) {
8371 return true;
8372 }
8373 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8374 return false;
8375 }
8376 return false;
8377 }
8378
8379 static final private boolean jj_3R_99() {
8380 if (jj_scan_token(PUBLIC)) {
8381 return true;
8382 }
8383 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8384 return false;
8385 }
8386 return false;
8387 }
8388
8389 static final private boolean jj_3R_284() {
8390 Token xsp;
8391
8392 xsp = jj_scanpos;
8393 if (jj_3R_322()) {
8394 jj_scanpos = xsp;
8395 if (jj_3R_323()) {
8396 jj_scanpos = xsp;
8397 if (jj_3R_324()) {
8398 jj_scanpos = xsp;
8399 if (jj_3R_325()) {
8400 jj_scanpos = xsp;
8401 if (jj_3R_326()) {
8402 jj_scanpos = xsp;
8403 if (jj_3R_327()) {
8404 jj_scanpos = xsp;
8405 if (jj_3R_328()) {
8406 jj_scanpos = xsp;
8407 if (jj_3R_329()) {
8408 jj_scanpos = xsp;
8409 if (jj_3R_330()) {
8410 return true;
8411 }
8412 if (jj_la == 0
8413 && jj_scanpos == jj_lastpos) {
8414 return false;
8415 }
8416 } else if (jj_la == 0
8417 && jj_scanpos == jj_lastpos) {
8418 return false;
8419 }
8420 } else if (jj_la == 0
8421 && jj_scanpos == jj_lastpos) {
8422 return false;
8423 }
8424 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8425 return false;
8426 }
8427 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8428 return false;
8429 }
8430 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8431 return false;
8432 }
8433 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8434 return false;
8435 }
8436 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8437 return false;
8438 }
8439 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8440 return false;
8441 }
8442 return false;
8443 }
8444
8445 static final private boolean jj_3R_246() {
8446 if (jj_3R_51()) {
8447 return true;
8448 }
8449 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8450 return false;
8451 }
8452 Token xsp;
8453
8454 while (true) {
8455 xsp = jj_scanpos;
8456 if (jj_3_10()) {
8457 jj_scanpos = xsp;
8458 break;
8459 }
8460 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8461 return false;
8462 }
8463 }
8464 return false;
8465 }
8466
8467 static final private boolean jj_3R_266() {
8468 Token xsp;
8469
8470 while (true) {
8471 xsp = jj_scanpos;
8472 if (jj_3R_284()) {
8473 jj_scanpos = xsp;
8474 break;
8475 }
8476 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8477 return false;
8478 }
8479 }
8480 if (jj_3R_58()) {
8481 return true;
8482 }
8483 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8484 return false;
8485 }
8486 if (jj_3R_285()) {
8487 return true;
8488 }
8489 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8490 return false;
8491 }
8492 xsp = jj_scanpos;
8493 if (jj_3R_286()) {
8494 jj_scanpos = xsp;
8495 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8496 return false;
8497 }
8498 xsp = jj_scanpos;
8499 if (jj_3R_287()) {
8500 jj_scanpos = xsp;
8501 if (jj_3R_288()) {
8502 return true;
8503 }
8504 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8505 return false;
8506 }
8507 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8508 return false;
8509 }
8510 return false;
8511 }
8512
8513 static final private boolean jj_3R_340() {
8514 if (jj_scan_token(ASSIGN)) {
8515 return true;
8516 }
8517 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8518 return false;
8519 }
8520 if (jj_3R_51()) {
8521 return true;
8522 }
8523 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8524 return false;
8525 }
8526 return false;
8527 }
8528
8529 static final private boolean jj_3R_313() {
8530 if (jj_scan_token(PRIVATE)) {
8531 return true;
8532 }
8533 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8534 return false;
8535 }
8536 return false;
8537 }
8538
8539 static final private boolean jj_3R_92() {
8540 if (jj_scan_token(PUBLIC)) {
8541 return true;
8542 }
8543 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8544 return false;
8545 }
8546 return false;
8547 }
8548
8549 static final private boolean jj_3R_291() {
8550 if (jj_scan_token(COMMA)) {
8551 return true;
8552 }
8553 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8554 return false;
8555 }
8556 if (jj_3R_290()) {
8557 return true;
8558 }
8559 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8560 return false;
8561 }
8562 return false;
8563 }
8564
8565 static final private boolean jj_3R_136() {
8566 if (jj_scan_token(NATIVE)) {
8567 return true;
8568 }
8569 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8570 return false;
8571 }
8572 return false;
8573 }
8574
8575 static final private boolean jj_3R_351() {
8576 if (jj_scan_token(LBRACKET)) {
8577 return true;
8578 }
8579 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8580 return false;
8581 }
8582 if (jj_scan_token(RBRACKET)) {
8583 return true;
8584 }
8585 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8586 return false;
8587 }
8588 return false;
8589 }
8590
8591 static final private boolean jj_3R_334() {
8592 if (jj_scan_token(PRIVATE)) {
8593 return true;
8594 }
8595 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8596 return false;
8597 }
8598 return false;
8599 }
8600
8601 static final private boolean jj_3R_139() {
8602 if (jj_scan_token(LBRACE)) {
8603 return true;
8604 }
8605 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8606 return false;
8607 }
8608 Token xsp;
8609
8610 xsp = jj_scanpos;
8611 if (jj_3R_246()) {
8612 jj_scanpos = xsp;
8613 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8614 return false;
8615 }
8616 xsp = jj_scanpos;
8617 if (jj_3R_247()) {
8618 jj_scanpos = xsp;
8619 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8620 return false;
8621 }
8622 if (jj_scan_token(RBRACE)) {
8623 return true;
8624 }
8625 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8626 return false;
8627 }
8628 return false;
8629 }
8630
8631 static final private boolean jj_3R_98() {
8632 if (jj_scan_token(FINAL)) {
8633 return true;
8634 }
8635 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8636 return false;
8637 }
8638 return false;
8639 }
8640
8641 static final private boolean jj_3R_84() {
8642 if (jj_scan_token(STRICTFP)) {
8643 return true;
8644 }
8645 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8646 return false;
8647 }
8648 return false;
8649 }
8650
8651 static final private boolean jj_3R_91() {
8652 if (jj_scan_token(FINAL)) {
8653 return true;
8654 }
8655 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8656 return false;
8657 }
8658 return false;
8659 }
8660
8661 static final private boolean jj_3R_77() {
8662 if (jj_scan_token(STRICTFP)) {
8663 return true;
8664 }
8665 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8666 return false;
8667 }
8668 return false;
8669 }
8670
8671 static final private boolean jj_3R_104() {
8672 if (jj_3R_60()) {
8673 return true;
8674 }
8675 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8676 return false;
8677 }
8678 return false;
8679 }
8680
8681 static final private boolean jj_3R_135() {
8682 if (jj_scan_token(FINAL)) {
8683 return true;
8684 }
8685 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8686 return false;
8687 }
8688 return false;
8689 }
8690
8691 static final private boolean jj_3R_103() {
8692 if (jj_3R_139()) {
8693 return true;
8694 }
8695 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8696 return false;
8697 }
8698 return false;
8699 }
8700
8701 static final private boolean jj_3R_51() {
8702 Token xsp;
8703
8704 xsp = jj_scanpos;
8705 if (jj_3R_103()) {
8706 jj_scanpos = xsp;
8707 if (jj_3R_104()) {
8708 return true;
8709 }
8710 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8711 return false;
8712 }
8713 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8714 return false;
8715 }
8716 return false;
8717 }
8718
8719 static final private boolean jj_3R_312() {
8720 if (jj_scan_token(PROTECTED)) {
8721 return true;
8722 }
8723 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8724 return false;
8725 }
8726 return false;
8727 }
8728
8729 static final private boolean jj_3R_339() {
8730 if (jj_scan_token(IDENTIFIER)) {
8731 return true;
8732 }
8733 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8734 return false;
8735 }
8736 Token xsp;
8737
8738 while (true) {
8739 xsp = jj_scanpos;
8740 if (jj_3R_351()) {
8741 jj_scanpos = xsp;
8742 break;
8743 }
8744 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8745 return false;
8746 }
8747 }
8748 return false;
8749 }
8750
8751 static final private boolean jj_3R_333() {
8752 if (jj_scan_token(PROTECTED)) {
8753 return true;
8754 }
8755 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8756 return false;
8757 }
8758 return false;
8759 }
8760
8761 static final private boolean jj_3R_83() {
8762 if (jj_scan_token(PRIVATE)) {
8763 return true;
8764 }
8765 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8766 return false;
8767 }
8768 return false;
8769 }
8770
8771 static final private boolean jj_3R_97() {
8772 if (jj_scan_token(ABSTRACT)) {
8773 return true;
8774 }
8775 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8776 return false;
8777 }
8778 return false;
8779 }
8780
8781 static final private boolean jj_3R_76() {
8782 if (jj_scan_token(PRIVATE)) {
8783 return true;
8784 }
8785 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8786 return false;
8787 }
8788 return false;
8789 }
8790
8791 static final private boolean jj_3R_90() {
8792 if (jj_scan_token(ABSTRACT)) {
8793 return true;
8794 }
8795 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8796 return false;
8797 }
8798 return false;
8799 }
8800
8801 static final private boolean jj_3R_311() {
8802 if (jj_scan_token(PUBLIC)) {
8803 return true;
8804 }
8805 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8806 return false;
8807 }
8808 return false;
8809 }
8810
8811 static final private boolean jj_3R_134() {
8812 if (jj_scan_token(ABSTRACT)) {
8813 return true;
8814 }
8815 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8816 return false;
8817 }
8818 return false;
8819 }
8820
8821 static final private boolean jj_3R_290() {
8822 if (jj_3R_339()) {
8823 return true;
8824 }
8825 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8826 return false;
8827 }
8828 Token xsp;
8829
8830 xsp = jj_scanpos;
8831 if (jj_3R_340()) {
8832 jj_scanpos = xsp;
8833 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8834 return false;
8835 }
8836 return false;
8837 }
8838
8839 static final private boolean jj_3R_315() {
8840 if (jj_scan_token(EXTENDS)) {
8841 return true;
8842 }
8843 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8844 return false;
8845 }
8846 if (jj_3R_321()) {
8847 return true;
8848 }
8849 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8850 return false;
8851 }
8852 return false;
8853 }
8854
8855 static final private boolean jj_3R_332() {
8856 if (jj_scan_token(PUBLIC)) {
8857 return true;
8858 }
8859 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8860 return false;
8861 }
8862 return false;
8863 }
8864
8865 static final private boolean jj_3_9() {
8866 if (jj_3R_48()) {
8867 return true;
8868 }
8869 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8870 return false;
8871 }
8872 return false;
8873 }
8874
8875 static final private boolean jj_3R_289() {
8876 Token xsp;
8877
8878 xsp = jj_scanpos;
8879 if (jj_3R_332()) {
8880 jj_scanpos = xsp;
8881 if (jj_3R_333()) {
8882 jj_scanpos = xsp;
8883 if (jj_3R_334()) {
8884 jj_scanpos = xsp;
8885 if (jj_3R_335()) {
8886 jj_scanpos = xsp;
8887 if (jj_3R_336()) {
8888 jj_scanpos = xsp;
8889 if (jj_3R_337()) {
8890 jj_scanpos = xsp;
8891 if (jj_3R_338()) {
8892 return true;
8893 }
8894 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8895 return false;
8896 }
8897 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8898 return false;
8899 }
8900 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8901 return false;
8902 }
8903 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8904 return false;
8905 }
8906 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8907 return false;
8908 }
8909 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8910 return false;
8911 }
8912 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8913 return false;
8914 }
8915 return false;
8916 }
8917
8918 static final private boolean jj_3R_305() {
8919 if (jj_scan_token(STRICTFP)) {
8920 return true;
8921 }
8922 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8923 return false;
8924 }
8925 return false;
8926 }
8927
8928 static final private boolean jj_3R_96() {
8929 if (jj_scan_token(STATIC)) {
8930 return true;
8931 }
8932 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8933 return false;
8934 }
8935 return false;
8936 }
8937
8938 static final private boolean jj_3R_50() {
8939 Token xsp;
8940
8941 xsp = jj_scanpos;
8942 if (jj_3R_96()) {
8943 jj_scanpos = xsp;
8944 if (jj_3R_97()) {
8945 jj_scanpos = xsp;
8946 if (jj_3R_98()) {
8947 jj_scanpos = xsp;
8948 if (jj_3R_99()) {
8949 jj_scanpos = xsp;
8950 if (jj_3R_100()) {
8951 jj_scanpos = xsp;
8952 if (jj_3R_101()) {
8953 jj_scanpos = xsp;
8954 if (jj_3R_102()) {
8955 return true;
8956 }
8957 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8958 return false;
8959 }
8960 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8961 return false;
8962 }
8963 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8964 return false;
8965 }
8966 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8967 return false;
8968 }
8969 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8970 return false;
8971 }
8972 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8973 return false;
8974 }
8975 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8976 return false;
8977 }
8978 return false;
8979 }
8980
8981 static final private boolean jj_3R_267() {
8982 Token xsp;
8983
8984 while (true) {
8985 xsp = jj_scanpos;
8986 if (jj_3R_289()) {
8987 jj_scanpos = xsp;
8988 break;
8989 }
8990 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8991 return false;
8992 }
8993 }
8994 if (jj_3R_63()) {
8995 return true;
8996 }
8997 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
8998 return false;
8999 }
9000 if (jj_3R_290()) {
9001 return true;
9002 }
9003 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9004 return false;
9005 }
9006 while (true) {
9007 xsp = jj_scanpos;
9008 if (jj_3R_291()) {
9009 jj_scanpos = xsp;
9010 break;
9011 }
9012 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9013 return false;
9014 }
9015 }
9016 if (jj_scan_token(SEMICOLON)) {
9017 return true;
9018 }
9019 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9020 return false;
9021 }
9022 return false;
9023 }
9024
9025 static final private boolean jj_3_8() {
9026 Token xsp;
9027
9028 while (true) {
9029 xsp = jj_scanpos;
9030 if (jj_3R_50()) {
9031 jj_scanpos = xsp;
9032 break;
9033 }
9034 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9035 return false;
9036 }
9037 }
9038 if (jj_scan_token(INTERFACE)) {
9039 return true;
9040 }
9041 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9042 return false;
9043 }
9044 return false;
9045 }
9046
9047 static final private boolean jj_3R_82() {
9048 if (jj_scan_token(PROTECTED)) {
9049 return true;
9050 }
9051 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9052 return false;
9053 }
9054 return false;
9055 }
9056
9057 static final private boolean jj_3R_89() {
9058 if (jj_scan_token(STATIC)) {
9059 return true;
9060 }
9061 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9062 return false;
9063 }
9064 return false;
9065 }
9066
9067 static final private boolean jj_3R_49() {
9068 Token xsp;
9069
9070 xsp = jj_scanpos;
9071 if (jj_3R_89()) {
9072 jj_scanpos = xsp;
9073 if (jj_3R_90()) {
9074 jj_scanpos = xsp;
9075 if (jj_3R_91()) {
9076 jj_scanpos = xsp;
9077 if (jj_3R_92()) {
9078 jj_scanpos = xsp;
9079 if (jj_3R_93()) {
9080 jj_scanpos = xsp;
9081 if (jj_3R_94()) {
9082 jj_scanpos = xsp;
9083 if (jj_3R_95()) {
9084 return true;
9085 }
9086 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9087 return false;
9088 }
9089 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9090 return false;
9091 }
9092 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9093 return false;
9094 }
9095 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9096 return false;
9097 }
9098 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9099 return false;
9100 }
9101 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9102 return false;
9103 }
9104 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9105 return false;
9106 }
9107 return false;
9108 }
9109
9110 static final private boolean jj_3R_310() {
9111 if (jj_scan_token(FINAL)) {
9112 return true;
9113 }
9114 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9115 return false;
9116 }
9117 return false;
9118 }
9119
9120 static final private boolean jj_3R_133() {
9121 if (jj_scan_token(STATIC)) {
9122 return true;
9123 }
9124 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9125 return false;
9126 }
9127 return false;
9128 }
9129
9130 static final private boolean jj_3_7() {
9131 Token xsp;
9132
9133 while (true) {
9134 xsp = jj_scanpos;
9135 if (jj_3R_49()) {
9136 jj_scanpos = xsp;
9137 break;
9138 }
9139 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9140 return false;
9141 }
9142 }
9143 if (jj_scan_token(CLASS)) {
9144 return true;
9145 }
9146 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9147 return false;
9148 }
9149 return false;
9150 }
9151
9152 static final private boolean jj_3R_75() {
9153 if (jj_scan_token(PROTECTED)) {
9154 return true;
9155 }
9156 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9157 return false;
9158 }
9159 return false;
9160 }
9161
9162 static final private boolean jj_3R_362() {
9163 if (jj_3R_267()) {
9164 return true;
9165 }
9166 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9167 return false;
9168 }
9169 return false;
9170 }
9171
9172 static final private boolean jj_3R_361() {
9173 if (jj_3R_266()) {
9174 return true;
9175 }
9176 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9177 return false;
9178 }
9179 return false;
9180 }
9181
9182 static final private boolean jj_3R_304() {
9183 if (jj_scan_token(PRIVATE)) {
9184 return true;
9185 }
9186 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9187 return false;
9188 }
9189 return false;
9190 }
9191
9192 static final private boolean jj_3R_360() {
9193 if (jj_3R_264()) {
9194 return true;
9195 }
9196 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9197 return false;
9198 }
9199 return false;
9200 }
9201
9202 static final private boolean jj_3R_81() {
9203 if (jj_scan_token(PUBLIC)) {
9204 return true;
9205 }
9206 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9207 return false;
9208 }
9209 return false;
9210 }
9211
9212 static final private boolean jj_3R_359() {
9213 if (jj_3R_263()) {
9214 return true;
9215 }
9216 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9217 return false;
9218 }
9219 return false;
9220 }
9221
9222 static final private boolean jj_3R_347() {
9223 Token xsp;
9224
9225 xsp = jj_scanpos;
9226 if (jj_3R_359()) {
9227 jj_scanpos = xsp;
9228 if (jj_3R_360()) {
9229 jj_scanpos = xsp;
9230 if (jj_3R_361()) {
9231 jj_scanpos = xsp;
9232 if (jj_3R_362()) {
9233 return true;
9234 }
9235 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9236 return false;
9237 }
9238 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9239 return false;
9240 }
9241 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9242 return false;
9243 }
9244 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9245 return false;
9246 }
9247 return false;
9248 }
9249
9250 static final private boolean jj_3R_316() {
9251 if (jj_3R_347()) {
9252 return true;
9253 }
9254 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9255 return false;
9256 }
9257 return false;
9258 }
9259
9260 static final private boolean jj_3R_74() {
9261 if (jj_scan_token(PUBLIC)) {
9262 return true;
9263 }
9264 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9265 return false;
9266 }
9267 return false;
9268 }
9269
9270 static final private boolean jj_3R_309() {
9271 if (jj_scan_token(ABSTRACT)) {
9272 return true;
9273 }
9274 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9275 return false;
9276 }
9277 return false;
9278 }
9279
9280 static final private boolean jj_3R_132() {
9281 if (jj_scan_token(PRIVATE)) {
9282 return true;
9283 }
9284 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9285 return false;
9286 }
9287 return false;
9288 }
9289
9290 static final private boolean jj_3R_87() {
9291 if (jj_scan_token(PRIVATE)) {
9292 return true;
9293 }
9294 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9295 return false;
9296 }
9297 return false;
9298 }
9299
9300 static final private boolean jj_3R_80() {
9301 if (jj_scan_token(FINAL)) {
9302 return true;
9303 }
9304 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9305 return false;
9306 }
9307 return false;
9308 }
9309
9310 static final private boolean jj_3R_176() {
9311 if (jj_scan_token(INTERFACE)) {
9312 return true;
9313 }
9314 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9315 return false;
9316 }
9317 if (jj_scan_token(IDENTIFIER)) {
9318 return true;
9319 }
9320 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9321 return false;
9322 }
9323 Token xsp;
9324
9325 xsp = jj_scanpos;
9326 if (jj_3R_315()) {
9327 jj_scanpos = xsp;
9328 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9329 return false;
9330 }
9331 if (jj_scan_token(LBRACE)) {
9332 return true;
9333 }
9334 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9335 return false;
9336 }
9337 while (true) {
9338 xsp = jj_scanpos;
9339 if (jj_3R_316()) {
9340 jj_scanpos = xsp;
9341 break;
9342 }
9343 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9344 return false;
9345 }
9346 }
9347 if (jj_scan_token(RBRACE)) {
9348 return true;
9349 }
9350 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9351 return false;
9352 }
9353 return false;
9354 }
9355
9356 static final private boolean jj_3R_303() {
9357 if (jj_scan_token(PROTECTED)) {
9358 return true;
9359 }
9360 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9361 return false;
9362 }
9363 return false;
9364 }
9365
9366 static final private boolean jj_3R_73() {
9367 if (jj_scan_token(FINAL)) {
9368 return true;
9369 }
9370 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9371 return false;
9372 }
9373 return false;
9374 }
9375
9376 static final private boolean jj_3R_308() {
9377 if (jj_scan_token(STATIC)) {
9378 return true;
9379 }
9380 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9381 return false;
9382 }
9383 return false;
9384 }
9385
9386 static final private boolean jj_3R_278() {
9387 Token xsp;
9388
9389 xsp = jj_scanpos;
9390 if (jj_3R_308()) {
9391 jj_scanpos = xsp;
9392 if (jj_3R_309()) {
9393 jj_scanpos = xsp;
9394 if (jj_3R_310()) {
9395 jj_scanpos = xsp;
9396 if (jj_3R_311()) {
9397 jj_scanpos = xsp;
9398 if (jj_3R_312()) {
9399 jj_scanpos = xsp;
9400 if (jj_3R_313()) {
9401 jj_scanpos = xsp;
9402 if (jj_3R_314()) {
9403 return true;
9404 }
9405 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9406 return false;
9407 }
9408 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9409 return false;
9410 }
9411 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9412 return false;
9413 }
9414 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9415 return false;
9416 }
9417 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9418 return false;
9419 }
9420 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9421 return false;
9422 }
9423 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9424 return false;
9425 }
9426 return false;
9427 }
9428
9429 static final private boolean jj_3R_264() {
9430 Token xsp;
9431
9432 while (true) {
9433 xsp = jj_scanpos;
9434 if (jj_3R_278()) {
9435 jj_scanpos = xsp;
9436 break;
9437 }
9438 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9439 return false;
9440 }
9441 }
9442 if (jj_3R_176()) {
9443 return true;
9444 }
9445 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9446 return false;
9447 }
9448 return false;
9449 }
9450
9451 static final private boolean jj_3R_131() {
9452 if (jj_scan_token(PROTECTED)) {
9453 return true;
9454 }
9455 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9456 return false;
9457 }
9458 return false;
9459 }
9460
9461 static final private boolean jj_3R_86() {
9462 if (jj_scan_token(PROTECTED)) {
9463 return true;
9464 }
9465 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9466 return false;
9467 }
9468 return false;
9469 }
9470
9471 static final private boolean jj_3R_79() {
9472 if (jj_scan_token(ABSTRACT)) {
9473 return true;
9474 }
9475 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9476 return false;
9477 }
9478 return false;
9479 }
9480
9481 static final private boolean jj_3R_302() {
9482 if (jj_scan_token(PUBLIC)) {
9483 return true;
9484 }
9485 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9486 return false;
9487 }
9488 return false;
9489 }
9490
9491 static final private boolean jj_3R_72() {
9492 if (jj_scan_token(ABSTRACT)) {
9493 return true;
9494 }
9495 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9496 return false;
9497 }
9498 return false;
9499 }
9500
9501 static final private boolean jj_3R_307() {
9502 if (jj_scan_token(IMPLEMENTS)) {
9503 return true;
9504 }
9505 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9506 return false;
9507 }
9508 if (jj_3R_321()) {
9509 return true;
9510 }
9511 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9512 return false;
9513 }
9514 return false;
9515 }
9516
9517 static final private boolean jj_3R_130() {
9518 if (jj_scan_token(PUBLIC)) {
9519 return true;
9520 }
9521 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9522 return false;
9523 }
9524 return false;
9525 }
9526
9527 static final private boolean jj_3R_88() {
9528 Token xsp;
9529
9530 xsp = jj_scanpos;
9531 if (jj_3R_130()) {
9532 jj_scanpos = xsp;
9533 if (jj_3R_131()) {
9534 jj_scanpos = xsp;
9535 if (jj_3R_132()) {
9536 jj_scanpos = xsp;
9537 if (jj_3R_133()) {
9538 jj_scanpos = xsp;
9539 if (jj_3R_134()) {
9540 jj_scanpos = xsp;
9541 if (jj_3R_135()) {
9542 jj_scanpos = xsp;
9543 if (jj_3R_136()) {
9544 jj_scanpos = xsp;
9545 if (jj_3R_137()) {
9546 jj_scanpos = xsp;
9547 if (jj_3R_138()) {
9548 return true;
9549 }
9550 if (jj_la == 0
9551 && jj_scanpos == jj_lastpos) {
9552 return false;
9553 }
9554 } else if (jj_la == 0
9555 && jj_scanpos == jj_lastpos) {
9556 return false;
9557 }
9558 } else if (jj_la == 0
9559 && jj_scanpos == jj_lastpos) {
9560 return false;
9561 }
9562 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9563 return false;
9564 }
9565 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9566 return false;
9567 }
9568 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9569 return false;
9570 }
9571 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9572 return false;
9573 }
9574 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9575 return false;
9576 }
9577 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9578 return false;
9579 }
9580 return false;
9581 }
9582
9583 static final private boolean jj_3_6() {
9584 if (jj_3R_48()) {
9585 return true;
9586 }
9587 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9588 return false;
9589 }
9590 return false;
9591 }
9592
9593 static final private boolean jj_3R_85() {
9594 if (jj_scan_token(PUBLIC)) {
9595 return true;
9596 }
9597 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9598 return false;
9599 }
9600 return false;
9601 }
9602
9603 static final private boolean jj_3R_46() {
9604 Token xsp;
9605
9606 xsp = jj_scanpos;
9607 if (jj_3R_85()) {
9608 jj_scanpos = xsp;
9609 if (jj_3R_86()) {
9610 jj_scanpos = xsp;
9611 if (jj_3R_87()) {
9612 return true;
9613 }
9614 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9615 return false;
9616 }
9617 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9618 return false;
9619 }
9620 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9621 return false;
9622 }
9623 return false;
9624 }
9625
9626 static final private boolean jj_3R_48() {
9627 Token xsp;
9628
9629 while (true) {
9630 xsp = jj_scanpos;
9631 if (jj_3R_88()) {
9632 jj_scanpos = xsp;
9633 break;
9634 }
9635 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9636 return false;
9637 }
9638 }
9639 if (jj_3R_58()) {
9640 return true;
9641 }
9642 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9643 return false;
9644 }
9645 if (jj_scan_token(IDENTIFIER)) {
9646 return true;
9647 }
9648 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9649 return false;
9650 }
9651 if (jj_scan_token(LPAREN)) {
9652 return true;
9653 }
9654 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9655 return false;
9656 }
9657 return false;
9658 }
9659
9660 static final private boolean jj_3_5() {
9661 Token xsp;
9662
9663 xsp = jj_scanpos;
9664 if (jj_3R_46()) {
9665 jj_scanpos = xsp;
9666 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9667 return false;
9668 }
9669 if (jj_3R_47()) {
9670 return true;
9671 }
9672 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9673 return false;
9674 }
9675 if (jj_scan_token(LPAREN)) {
9676 return true;
9677 }
9678 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9679 return false;
9680 }
9681 return false;
9682 }
9683
9684 static final private boolean jj_3R_301() {
9685 if (jj_scan_token(FINAL)) {
9686 return true;
9687 }
9688 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9689 return false;
9690 }
9691 return false;
9692 }
9693
9694 static final private boolean jj_3R_45() {
9695 Token xsp;
9696
9697 xsp = jj_scanpos;
9698 if (jj_3R_78()) {
9699 jj_scanpos = xsp;
9700 if (jj_3R_79()) {
9701 jj_scanpos = xsp;
9702 if (jj_3R_80()) {
9703 jj_scanpos = xsp;
9704 if (jj_3R_81()) {
9705 jj_scanpos = xsp;
9706 if (jj_3R_82()) {
9707 jj_scanpos = xsp;
9708 if (jj_3R_83()) {
9709 jj_scanpos = xsp;
9710 if (jj_3R_84()) {
9711 return true;
9712 }
9713 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9714 return false;
9715 }
9716 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9717 return false;
9718 }
9719 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9720 return false;
9721 }
9722 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9723 return false;
9724 }
9725 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9726 return false;
9727 }
9728 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9729 return false;
9730 }
9731 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9732 return false;
9733 }
9734 return false;
9735 }
9736
9737 static final private boolean jj_3R_78() {
9738 if (jj_scan_token(STATIC)) {
9739 return true;
9740 }
9741 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9742 return false;
9743 }
9744 return false;
9745 }
9746
9747 static final private boolean jj_3_4() {
9748 Token xsp;
9749
9750 while (true) {
9751 xsp = jj_scanpos;
9752 if (jj_3R_45()) {
9753 jj_scanpos = xsp;
9754 break;
9755 }
9756 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9757 return false;
9758 }
9759 }
9760 if (jj_scan_token(INTERFACE)) {
9761 return true;
9762 }
9763 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9764 return false;
9765 }
9766 return false;
9767 }
9768
9769 static final private boolean jj_3R_44() {
9770 Token xsp;
9771
9772 xsp = jj_scanpos;
9773 if (jj_3R_71()) {
9774 jj_scanpos = xsp;
9775 if (jj_3R_72()) {
9776 jj_scanpos = xsp;
9777 if (jj_3R_73()) {
9778 jj_scanpos = xsp;
9779 if (jj_3R_74()) {
9780 jj_scanpos = xsp;
9781 if (jj_3R_75()) {
9782 jj_scanpos = xsp;
9783 if (jj_3R_76()) {
9784 jj_scanpos = xsp;
9785 if (jj_3R_77()) {
9786 return true;
9787 }
9788 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9789 return false;
9790 }
9791 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9792 return false;
9793 }
9794 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9795 return false;
9796 }
9797 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9798 return false;
9799 }
9800 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9801 return false;
9802 }
9803 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9804 return false;
9805 }
9806 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9807 return false;
9808 }
9809 return false;
9810 }
9811
9812 static final private boolean jj_3R_71() {
9813 if (jj_scan_token(STATIC)) {
9814 return true;
9815 }
9816 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9817 return false;
9818 }
9819 return false;
9820 }
9821
9822 static final private boolean jj_3R_260() {
9823 if (jj_3R_267()) {
9824 return true;
9825 }
9826 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9827 return false;
9828 }
9829 return false;
9830 }
9831
9832 static final private boolean jj_3_3() {
9833 Token xsp;
9834
9835 while (true) {
9836 xsp = jj_scanpos;
9837 if (jj_3R_44()) {
9838 jj_scanpos = xsp;
9839 break;
9840 }
9841 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9842 return false;
9843 }
9844 }
9845 if (jj_scan_token(CLASS)) {
9846 return true;
9847 }
9848 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9849 return false;
9850 }
9851 return false;
9852 }
9853
9854 static final private boolean jj_3R_259() {
9855 if (jj_3R_266()) {
9856 return true;
9857 }
9858 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9859 return false;
9860 }
9861 return false;
9862 }
9863
9864 static final private boolean jj_3R_258() {
9865 if (jj_3R_265()) {
9866 return true;
9867 }
9868 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9869 return false;
9870 }
9871 return false;
9872 }
9873
9874 static final private boolean jj_3R_300() {
9875 if (jj_scan_token(ABSTRACT)) {
9876 return true;
9877 }
9878 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9879 return false;
9880 }
9881 return false;
9882 }
9883
9884 static final private boolean jj_3R_257() {
9885 if (jj_3R_264()) {
9886 return true;
9887 }
9888 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9889 return false;
9890 }
9891 return false;
9892 }
9893
9894 static final private boolean jj_3R_68() {
9895 if (jj_scan_token(STRICTFP)) {
9896 return true;
9897 }
9898 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9899 return false;
9900 }
9901 return false;
9902 }
9903
9904 static final private boolean jj_3R_306() {
9905 if (jj_scan_token(EXTENDS)) {
9906 return true;
9907 }
9908 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9909 return false;
9910 }
9911 if (jj_3R_47()) {
9912 return true;
9913 }
9914 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9915 return false;
9916 }
9917 return false;
9918 }
9919
9920 static final private boolean jj_3R_256() {
9921 if (jj_3R_263()) {
9922 return true;
9923 }
9924 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9925 return false;
9926 }
9927 return false;
9928 }
9929
9930 static final private boolean jj_3_2() {
9931 if (jj_3R_43()) {
9932 return true;
9933 }
9934 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9935 return false;
9936 }
9937 return false;
9938 }
9939
9940 static final private boolean jj_3R_251() {
9941 Token xsp;
9942
9943 xsp = jj_scanpos;
9944 if (jj_3_2()) {
9945 jj_scanpos = xsp;
9946 if (jj_3R_256()) {
9947 jj_scanpos = xsp;
9948 if (jj_3R_257()) {
9949 jj_scanpos = xsp;
9950 if (jj_3R_258()) {
9951 jj_scanpos = xsp;
9952 if (jj_3R_259()) {
9953 jj_scanpos = xsp;
9954 if (jj_3R_260()) {
9955 return true;
9956 }
9957 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9958 return false;
9959 }
9960 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9961 return false;
9962 }
9963 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9964 return false;
9965 }
9966 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9967 return false;
9968 }
9969 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9970 return false;
9971 }
9972 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9973 return false;
9974 }
9975 return false;
9976 }
9977
9978 static final private boolean jj_3R_277() {
9979 Token xsp;
9980
9981 xsp = jj_scanpos;
9982 if (jj_3R_299()) {
9983 jj_scanpos = xsp;
9984 if (jj_3R_300()) {
9985 jj_scanpos = xsp;
9986 if (jj_3R_301()) {
9987 jj_scanpos = xsp;
9988 if (jj_3R_302()) {
9989 jj_scanpos = xsp;
9990 if (jj_3R_303()) {
9991 jj_scanpos = xsp;
9992 if (jj_3R_304()) {
9993 jj_scanpos = xsp;
9994 if (jj_3R_305()) {
9995 return true;
9996 }
9997 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
9998 return false;
9999 }
0000 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0001 return false;
0002 }
0003 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0004 return false;
0005 }
0006 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0007 return false;
0008 }
0009 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0010 return false;
0011 }
0012 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0013 return false;
0014 }
0015 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0016 return false;
0017 }
0018 return false;
0019 }
0020
0021 static final private boolean jj_3R_299() {
0022 if (jj_scan_token(STATIC)) {
0023 return true;
0024 }
0025 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0026 return false;
0027 }
0028 return false;
0029 }
0030
0031 static final private boolean jj_3R_67() {
0032 if (jj_scan_token(PUBLIC)) {
0033 return true;
0034 }
0035 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0036 return false;
0037 }
0038 return false;
0039 }
0040
0041 static final private boolean jj_3R_248() {
0042 if (jj_3R_251()) {
0043 return true;
0044 }
0045 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0046 return false;
0047 }
0048 return false;
0049 }
0050
0051 static final private boolean jj_3R_263() {
0052 Token xsp;
0053
0054 while (true) {
0055 xsp = jj_scanpos;
0056 if (jj_3R_277()) {
0057 jj_scanpos = xsp;
0058 break;
0059 }
0060 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0061 return false;
0062 }
0063 }
0064 if (jj_3R_175()) {
0065 return true;
0066 }
0067 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0068 return false;
0069 }
0070 return false;
0071 }
0072
0073 static final private boolean jj_3R_243() {
0074 if (jj_scan_token(LBRACE)) {
0075 return true;
0076 }
0077 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0078 return false;
0079 }
0080 Token xsp;
0081
0082 while (true) {
0083 xsp = jj_scanpos;
0084 if (jj_3R_248()) {
0085 jj_scanpos = xsp;
0086 break;
0087 }
0088 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0089 return false;
0090 }
0091 }
0092 if (jj_scan_token(RBRACE)) {
0093 return true;
0094 }
0095 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0096 return false;
0097 }
0098 return false;
0099 }
0100
0101 static final private boolean jj_3R_66() {
0102 if (jj_scan_token(FINAL)) {
0103 return true;
0104 }
0105 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0106 return false;
0107 }
0108 return false;
0109 }
0110
0111 static final private boolean jj_3R_175() {
0112 if (jj_scan_token(CLASS)) {
0113 return true;
0114 }
0115 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0116 return false;
0117 }
0118 if (jj_scan_token(IDENTIFIER)) {
0119 return true;
0120 }
0121 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0122 return false;
0123 }
0124 Token xsp;
0125
0126 xsp = jj_scanpos;
0127 if (jj_3R_306()) {
0128 jj_scanpos = xsp;
0129 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0130 return false;
0131 }
0132 xsp = jj_scanpos;
0133 if (jj_3R_307()) {
0134 jj_scanpos = xsp;
0135 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0136 return false;
0137 }
0138 if (jj_3R_243()) {
0139 return true;
0140 }
0141 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0142 return false;
0143 }
0144 return false;
0145 }
0146
0147 static final private boolean jj_3R_42() {
0148 Token xsp;
0149
0150 xsp = jj_scanpos;
0151 if (jj_3R_65()) {
0152 jj_scanpos = xsp;
0153 if (jj_3R_66()) {
0154 jj_scanpos = xsp;
0155 if (jj_3R_67()) {
0156 jj_scanpos = xsp;
0157 if (jj_3R_68()) {
0158 return true;
0159 }
0160 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0161 return false;
0162 }
0163 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0164 return false;
0165 }
0166 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0167 return false;
0168 }
0169 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0170 return false;
0171 }
0172 return false;
0173 }
0174
0175 static final private boolean jj_3R_65() {
0176 if (jj_scan_token(ABSTRACT)) {
0177 return true;
0178 }
0179 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0180 return false;
0181 }
0182 return false;
0183 }
0184
0185 static final private boolean jj_3_1() {
0186 Token xsp;
0187
0188 while (true) {
0189 xsp = jj_scanpos;
0190 if (jj_3R_42()) {
0191 jj_scanpos = xsp;
0192 break;
0193 }
0194 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0195 return false;
0196 }
0197 }
0198 if (jj_scan_token(CLASS)) {
0199 return true;
0200 }
0201 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0202 return false;
0203 }
0204 return false;
0205 }
0206
0207 static final private boolean jj_3R_376() {
0208 if (jj_scan_token(FINALLY)) {
0209 return true;
0210 }
0211 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0212 return false;
0213 }
0214 if (jj_3R_70()) {
0215 return true;
0216 }
0217 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0218 return false;
0219 }
0220 return false;
0221 }
0222
0223 static final private boolean jj_3R_375() {
0224 if (jj_scan_token(CATCH)) {
0225 return true;
0226 }
0227 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0228 return false;
0229 }
0230 if (jj_scan_token(LPAREN)) {
0231 return true;
0232 }
0233 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0234 return false;
0235 }
0236 if (jj_3R_348()) {
0237 return true;
0238 }
0239 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0240 return false;
0241 }
0242 if (jj_scan_token(RPAREN)) {
0243 return true;
0244 }
0245 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0246 return false;
0247 }
0248 if (jj_3R_70()) {
0249 return true;
0250 }
0251 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0252 return false;
0253 }
0254 return false;
0255 }
0256
0257 static final private boolean jj_3R_225() {
0258 if (jj_scan_token(TRY)) {
0259 return true;
0260 }
0261 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0262 return false;
0263 }
0264 if (jj_3R_70()) {
0265 return true;
0266 }
0267 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0268 return false;
0269 }
0270 Token xsp;
0271
0272 while (true) {
0273 xsp = jj_scanpos;
0274 if (jj_3R_375()) {
0275 jj_scanpos = xsp;
0276 break;
0277 }
0278 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0279 return false;
0280 }
0281 }
0282 xsp = jj_scanpos;
0283 if (jj_3R_376()) {
0284 jj_scanpos = xsp;
0285 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0286 return false;
0287 }
0288 return false;
0289 }
0290
0291 static final private boolean jj_3R_371() {
0292 if (jj_3R_382()) {
0293 return true;
0294 }
0295 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0296 return false;
0297 }
0298 return false;
0299 }
0300
0301 static final private boolean jj_3R_224() {
0302 if (jj_scan_token(SYNCHRONIZED)) {
0303 return true;
0304 }
0305 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0306 return false;
0307 }
0308 if (jj_scan_token(LPAREN)) {
0309 return true;
0310 }
0311 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0312 return false;
0313 }
0314 if (jj_3R_60()) {
0315 return true;
0316 }
0317 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0318 return false;
0319 }
0320 if (jj_scan_token(RPAREN)) {
0321 return true;
0322 }
0323 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0324 return false;
0325 }
0326 if (jj_3R_70()) {
0327 return true;
0328 }
0329 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0330 return false;
0331 }
0332 return false;
0333 }
0334
0335 static final private boolean jj_3R_374() {
0336 if (jj_3R_60()) {
0337 return true;
0338 }
0339 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0340 return false;
0341 }
0342 return false;
0343 }
0344
0345 static final private boolean jj_3R_373() {
0346 if (jj_scan_token(IDENTIFIER)) {
0347 return true;
0348 }
0349 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0350 return false;
0351 }
0352 return false;
0353 }
0354
0355 static final private boolean jj_3R_223() {
0356 if (jj_scan_token(THROW)) {
0357 return true;
0358 }
0359 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0360 return false;
0361 }
0362 if (jj_3R_60()) {
0363 return true;
0364 }
0365 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0366 return false;
0367 }
0368 if (jj_scan_token(SEMICOLON)) {
0369 return true;
0370 }
0371 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0372 return false;
0373 }
0374 return false;
0375 }
0376
0377 static final private boolean jj_3R_393() {
0378 if (jj_scan_token(COMMA)) {
0379 return true;
0380 }
0381 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0382 return false;
0383 }
0384 if (jj_3R_214()) {
0385 return true;
0386 }
0387 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0388 return false;
0389 }
0390 return false;
0391 }
0392
0393 static final private boolean jj_3R_222() {
0394 if (jj_scan_token(RETURN)) {
0395 return true;
0396 }
0397 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0398 return false;
0399 }
0400 Token xsp;
0401
0402 xsp = jj_scanpos;
0403 if (jj_3R_374()) {
0404 jj_scanpos = xsp;
0405 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0406 return false;
0407 }
0408 if (jj_scan_token(SEMICOLON)) {
0409 return true;
0410 }
0411 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0412 return false;
0413 }
0414 return false;
0415 }
0416
0417 static final private boolean jj_3R_372() {
0418 if (jj_scan_token(IDENTIFIER)) {
0419 return true;
0420 }
0421 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0422 return false;
0423 }
0424 return false;
0425 }
0426
0427 static final private boolean jj_3R_221() {
0428 if (jj_scan_token(CONTINUE)) {
0429 return true;
0430 }
0431 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0432 return false;
0433 }
0434 Token xsp;
0435
0436 xsp = jj_scanpos;
0437 if (jj_3R_373()) {
0438 jj_scanpos = xsp;
0439 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0440 return false;
0441 }
0442 if (jj_scan_token(SEMICOLON)) {
0443 return true;
0444 }
0445 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0446 return false;
0447 }
0448 return false;
0449 }
0450
0451 static final private boolean jj_3R_370() {
0452 if (jj_3R_60()) {
0453 return true;
0454 }
0455 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0456 return false;
0457 }
0458 return false;
0459 }
0460
0461 static final private boolean jj_3R_220() {
0462 if (jj_scan_token(BREAK)) {
0463 return true;
0464 }
0465 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0466 return false;
0467 }
0468 Token xsp;
0469
0470 xsp = jj_scanpos;
0471 if (jj_3R_372()) {
0472 jj_scanpos = xsp;
0473 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0474 return false;
0475 }
0476 if (jj_scan_token(SEMICOLON)) {
0477 return true;
0478 }
0479 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0480 return false;
0481 }
0482 return false;
0483 }
0484
0485 static final private boolean jj_3R_368() {
0486 if (jj_scan_token(ELSE)) {
0487 return true;
0488 }
0489 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0490 return false;
0491 }
0492 if (jj_3R_174()) {
0493 return true;
0494 }
0495 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0496 return false;
0497 }
0498 return false;
0499 }
0500
0501 static final private boolean jj_3R_382() {
0502 if (jj_3R_392()) {
0503 return true;
0504 }
0505 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0506 return false;
0507 }
0508 return false;
0509 }
0510
0511 static final private boolean jj_3R_64() {
0512 if (jj_scan_token(FINAL)) {
0513 return true;
0514 }
0515 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0516 return false;
0517 }
0518 return false;
0519 }
0520
0521 static final private boolean jj_3_29() {
0522 Token xsp;
0523
0524 xsp = jj_scanpos;
0525 if (jj_3R_64()) {
0526 jj_scanpos = xsp;
0527 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0528 return false;
0529 }
0530 if (jj_3R_63()) {
0531 return true;
0532 }
0533 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0534 return false;
0535 }
0536 if (jj_scan_token(IDENTIFIER)) {
0537 return true;
0538 }
0539 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0540 return false;
0541 }
0542 return false;
0543 }
0544
0545 static final private boolean jj_3R_392() {
0546 if (jj_3R_214()) {
0547 return true;
0548 }
0549 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0550 return false;
0551 }
0552 Token xsp;
0553
0554 while (true) {
0555 xsp = jj_scanpos;
0556 if (jj_3R_393()) {
0557 jj_scanpos = xsp;
0558 break;
0559 }
0560 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0561 return false;
0562 }
0563 }
0564 return false;
0565 }
0566
0567 static final private boolean jj_3R_369() {
0568 if (jj_3R_381()) {
0569 return true;
0570 }
0571 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0572 return false;
0573 }
0574 return false;
0575 }
0576
0577 static final private boolean jj_3R_391() {
0578 if (jj_3R_392()) {
0579 return true;
0580 }
0581 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0582 return false;
0583 }
0584 return false;
0585 }
0586
0587 static final private boolean jj_3R_390() {
0588 if (jj_3R_173()) {
0589 return true;
0590 }
0591 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0592 return false;
0593 }
0594 return false;
0595 }
0596
0597 static final private boolean jj_3R_381() {
0598 Token xsp;
0599
0600 xsp = jj_scanpos;
0601 if (jj_3R_390()) {
0602 jj_scanpos = xsp;
0603 if (jj_3R_391()) {
0604 return true;
0605 }
0606 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0607 return false;
0608 }
0609 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0610 return false;
0611 }
0612 return false;
0613 }
0614
0615 static final private boolean jj_3R_219() {
0616 if (jj_scan_token(FOR)) {
0617 return true;
0618 }
0619 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0620 return false;
0621 }
0622 if (jj_scan_token(LPAREN)) {
0623 return true;
0624 }
0625 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0626 return false;
0627 }
0628 Token xsp;
0629
0630 xsp = jj_scanpos;
0631 if (jj_3R_369()) {
0632 jj_scanpos = xsp;
0633 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0634 return false;
0635 }
0636 if (jj_scan_token(SEMICOLON)) {
0637 return true;
0638 }
0639 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0640 return false;
0641 }
0642 xsp = jj_scanpos;
0643 if (jj_3R_370()) {
0644 jj_scanpos = xsp;
0645 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0646 return false;
0647 }
0648 if (jj_scan_token(SEMICOLON)) {
0649 return true;
0650 }
0651 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0652 return false;
0653 }
0654 xsp = jj_scanpos;
0655 if (jj_3R_371()) {
0656 jj_scanpos = xsp;
0657 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0658 return false;
0659 }
0660 if (jj_scan_token(RPAREN)) {
0661 return true;
0662 }
0663 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0664 return false;
0665 }
0666 if (jj_3R_174()) {
0667 return true;
0668 }
0669 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0670 return false;
0671 }
0672 return false;
0673 }
0674
0675 static final private boolean jj_3R_218() {
0676 if (jj_scan_token(DO)) {
0677 return true;
0678 }
0679 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0680 return false;
0681 }
0682 if (jj_3R_174()) {
0683 return true;
0684 }
0685 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0686 return false;
0687 }
0688 if (jj_scan_token(WHILE)) {
0689 return true;
0690 }
0691 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0692 return false;
0693 }
0694 if (jj_scan_token(LPAREN)) {
0695 return true;
0696 }
0697 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0698 return false;
0699 }
0700 if (jj_3R_60()) {
0701 return true;
0702 }
0703 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0704 return false;
0705 }
0706 if (jj_scan_token(RPAREN)) {
0707 return true;
0708 }
0709 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0710 return false;
0711 }
0712 if (jj_scan_token(SEMICOLON)) {
0713 return true;
0714 }
0715 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0716 return false;
0717 }
0718 return false;
0719 }
0720
0721 static final private boolean jj_3R_217() {
0722 if (jj_scan_token(WHILE)) {
0723 return true;
0724 }
0725 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0726 return false;
0727 }
0728 if (jj_scan_token(LPAREN)) {
0729 return true;
0730 }
0731 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0732 return false;
0733 }
0734 if (jj_3R_60()) {
0735 return true;
0736 }
0737 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0738 return false;
0739 }
0740 if (jj_scan_token(RPAREN)) {
0741 return true;
0742 }
0743 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0744 return false;
0745 }
0746 if (jj_3R_174()) {
0747 return true;
0748 }
0749 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0750 return false;
0751 }
0752 return false;
0753 }
0754
0755 static final private boolean jj_3R_380() {
0756 if (jj_3R_157()) {
0757 return true;
0758 }
0759 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0760 return false;
0761 }
0762 return false;
0763 }
0764
0765 static final private boolean jj_3R_216() {
0766 if (jj_scan_token(IF)) {
0767 return true;
0768 }
0769 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0770 return false;
0771 }
0772 if (jj_scan_token(LPAREN)) {
0773 return true;
0774 }
0775 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0776 return false;
0777 }
0778 if (jj_3R_60()) {
0779 return true;
0780 }
0781 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0782 return false;
0783 }
0784 if (jj_scan_token(RPAREN)) {
0785 return true;
0786 }
0787 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0788 return false;
0789 }
0790 if (jj_3R_174()) {
0791 return true;
0792 }
0793 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0794 return false;
0795 }
0796 Token xsp;
0797
0798 xsp = jj_scanpos;
0799 if (jj_3R_368()) {
0800 jj_scanpos = xsp;
0801 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0802 return false;
0803 }
0804 return false;
0805 }
0806
0807 static final private boolean jj_3R_389() {
0808 if (jj_scan_token(_DEFAULT)) {
0809 return true;
0810 }
0811 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0812 return false;
0813 }
0814 if (jj_scan_token(COLON)) {
0815 return true;
0816 }
0817 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0818 return false;
0819 }
0820 return false;
0821 }
0822
0823 static final private boolean jj_3R_388() {
0824 if (jj_scan_token(CASE)) {
0825 return true;
0826 }
0827 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0828 return false;
0829 }
0830 if (jj_3R_60()) {
0831 return true;
0832 }
0833 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0834 return false;
0835 }
0836 if (jj_scan_token(COLON)) {
0837 return true;
0838 }
0839 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0840 return false;
0841 }
0842 return false;
0843 }
0844
0845 static final private boolean jj_3R_379() {
0846 Token xsp;
0847
0848 xsp = jj_scanpos;
0849 if (jj_3R_388()) {
0850 jj_scanpos = xsp;
0851 if (jj_3R_389()) {
0852 return true;
0853 }
0854 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0855 return false;
0856 }
0857 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0858 return false;
0859 }
0860 return false;
0861 }
0862
0863 static final private boolean jj_3R_366() {
0864 if (jj_scan_token(COMMA)) {
0865 return true;
0866 }
0867 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0868 return false;
0869 }
0870 if (jj_3R_290()) {
0871 return true;
0872 }
0873 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0874 return false;
0875 }
0876 return false;
0877 }
0878
0879 static final private boolean jj_3R_367() {
0880 if (jj_3R_379()) {
0881 return true;
0882 }
0883 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0884 return false;
0885 }
0886 Token xsp;
0887
0888 while (true) {
0889 xsp = jj_scanpos;
0890 if (jj_3R_380()) {
0891 jj_scanpos = xsp;
0892 break;
0893 }
0894 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0895 return false;
0896 }
0897 }
0898 return false;
0899 }
0900
0901 static final private boolean jj_3R_215() {
0902 if (jj_scan_token(SWITCH)) {
0903 return true;
0904 }
0905 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0906 return false;
0907 }
0908 if (jj_scan_token(LPAREN)) {
0909 return true;
0910 }
0911 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0912 return false;
0913 }
0914 if (jj_3R_60()) {
0915 return true;
0916 }
0917 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0918 return false;
0919 }
0920 if (jj_scan_token(RPAREN)) {
0921 return true;
0922 }
0923 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0924 return false;
0925 }
0926 if (jj_scan_token(LBRACE)) {
0927 return true;
0928 }
0929 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0930 return false;
0931 }
0932 Token xsp;
0933
0934 while (true) {
0935 xsp = jj_scanpos;
0936 if (jj_3R_367()) {
0937 jj_scanpos = xsp;
0938 break;
0939 }
0940 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0941 return false;
0942 }
0943 }
0944 if (jj_scan_token(RBRACE)) {
0945 return true;
0946 }
0947 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0948 return false;
0949 }
0950 return false;
0951 }
0952
0953 static final private boolean jj_3R_387() {
0954 if (jj_3R_180()) {
0955 return true;
0956 }
0957 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0958 return false;
0959 }
0960 if (jj_3R_60()) {
0961 return true;
0962 }
0963 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0964 return false;
0965 }
0966 return false;
0967 }
0968
0969 static final private boolean jj_3R_386() {
0970 if (jj_scan_token(DECR)) {
0971 return true;
0972 }
0973 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0974 return false;
0975 }
0976 return false;
0977 }
0978
0979 static final private boolean jj_3R_385() {
0980 if (jj_scan_token(INCR)) {
0981 return true;
0982 }
0983 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
0984 return false;
0985 }
0986 return false;
0987 }
0988
0989 static final private boolean jj_3R_378() {
0990 Token xsp;
0991
0992 xsp = jj_scanpos;
0993 if (jj_3R_385()) {
0994 jj_scanpos = xsp;
0995 if (jj_3R_386()) {
0996 jj_scanpos = xsp;
0997 if (jj_3R_387()) {
0998 return true;
0999 }
1000 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1001 return false;
1002 }
1003 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1004 return false;
1005 }
1006 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1007 return false;
1008 }
1009 return false;
1010 }
1011
1012 static final private boolean jj_3R_230() {
1013 if (jj_3R_53()) {
1014 return true;
1015 }
1016 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1017 return false;
1018 }
1019 Token xsp;
1020
1021 xsp = jj_scanpos;
1022 if (jj_3R_378()) {
1023 jj_scanpos = xsp;
1024 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1025 return false;
1026 }
1027 return false;
1028 }
1029
1030 static final private boolean jj_3R_229() {
1031 if (jj_3R_237()) {
1032 return true;
1033 }
1034 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1035 return false;
1036 }
1037 return false;
1038 }
1039
1040 static final private boolean jj_3R_214() {
1041 Token xsp;
1042
1043 xsp = jj_scanpos;
1044 if (jj_3R_228()) {
1045 jj_scanpos = xsp;
1046 if (jj_3R_229()) {
1047 jj_scanpos = xsp;
1048 if (jj_3R_230()) {
1049 return true;
1050 }
1051 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1052 return false;
1053 }
1054 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1055 return false;
1056 }
1057 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1058 return false;
1059 }
1060 return false;
1061 }
1062
1063 static final private boolean jj_3R_228() {
1064 if (jj_3R_236()) {
1065 return true;
1066 }
1067 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1068 return false;
1069 }
1070 return false;
1071 }
1072
1073 static final private boolean jj_3R_213() {
1074 if (jj_scan_token(SEMICOLON)) {
1075 return true;
1076 }
1077 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1078 return false;
1079 }
1080 return false;
1081 }
1082
1083 static final private boolean jj_3R_182() {
1084 if (jj_scan_token(FINAL)) {
1085 return true;
1086 }
1087 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1088 return false;
1089 }
1090 return false;
1091 }
1092
1093 static final private boolean jj_3R_173() {
1094 Token xsp;
1095
1096 xsp = jj_scanpos;
1097 if (jj_3R_182()) {
1098 jj_scanpos = xsp;
1099 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1100 return false;
1101 }
1102 if (jj_3R_63()) {
1103 return true;
1104 }
1105 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1106 return false;
1107 }
1108 if (jj_3R_290()) {
1109 return true;
1110 }
1111 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1112 return false;
1113 }
1114 while (true) {
1115 xsp = jj_scanpos;
1116 if (jj_3R_366()) {
1117 jj_scanpos = xsp;
1118 break;
1119 }
1120 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1121 return false;
1122 }
1123 }
1124 return false;
1125 }
1126
1127 static final private boolean jj_3R_62() {
1128 if (jj_scan_token(FINAL)) {
1129 return true;
1130 }
1131 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1132 return false;
1133 }
1134 return false;
1135 }
1136
1137 static final private boolean jj_3_28() {
1138 Token xsp;
1139
1140 xsp = jj_scanpos;
1141 if (jj_3R_62()) {
1142 jj_scanpos = xsp;
1143 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1144 return false;
1145 }
1146 if (jj_3R_63()) {
1147 return true;
1148 }
1149 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1150 return false;
1151 }
1152 if (jj_scan_token(IDENTIFIER)) {
1153 return true;
1154 }
1155 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1156 return false;
1157 }
1158 return false;
1159 }
1160
1161 static final private boolean jj_3R_164() {
1162 if (jj_3R_176()) {
1163 return true;
1164 }
1165 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1166 return false;
1167 }
1168 return false;
1169 }
1170
1171 static final private boolean jj_3R_163() {
1172 if (jj_3R_175()) {
1173 return true;
1174 }
1175 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1176 return false;
1177 }
1178 return false;
1179 }
1180
1181 static final private boolean jj_3R_162() {
1182 if (jj_3R_174()) {
1183 return true;
1184 }
1185 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1186 return false;
1187 }
1188 return false;
1189 }
1190
1191 static final private boolean jj_3R_129() {
1192 if (jj_3R_157()) {
1193 return true;
1194 }
1195 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1196 return false;
1197 }
1198 return false;
1199 }
1200
1201 static final private boolean jj_3R_157() {
1202 Token xsp;
1203
1204 xsp = jj_scanpos;
1205 if (jj_3R_161()) {
1206 jj_scanpos = xsp;
1207 if (jj_3R_162()) {
1208 jj_scanpos = xsp;
1209 if (jj_3R_163()) {
1210 jj_scanpos = xsp;
1211 if (jj_3R_164()) {
1212 return true;
1213 }
1214 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1215 return false;
1216 }
1217 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1218 return false;
1219 }
1220 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1221 return false;
1222 }
1223 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1224 return false;
1225 }
1226 return false;
1227 }
1228
1229 static final private boolean jj_3R_161() {
1230 if (jj_3R_173()) {
1231 return true;
1232 }
1233 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1234 return false;
1235 }
1236 if (jj_scan_token(SEMICOLON)) {
1237 return true;
1238 }
1239 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1240 return false;
1241 }
1242 return false;
1243 }
1244
1245 static final private boolean jj_3R_70() {
1246 if (jj_scan_token(LBRACE)) {
1247 return true;
1248 }
1249 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1250 return false;
1251 }
1252 Token xsp;
1253
1254 while (true) {
1255 xsp = jj_scanpos;
1256 if (jj_3R_129()) {
1257 jj_scanpos = xsp;
1258 break;
1259 }
1260 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1261 return false;
1262 }
1263 }
1264 if (jj_scan_token(RBRACE)) {
1265 return true;
1266 }
1267 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1268 return false;
1269 }
1270 return false;
1271 }
1272
1273 static final private boolean jj_3R_61() {
1274 if (jj_scan_token(IDENTIFIER)) {
1275 return true;
1276 }
1277 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1278 return false;
1279 }
1280 if (jj_scan_token(COLON)) {
1281 return true;
1282 }
1283 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1284 return false;
1285 }
1286 if (jj_3R_174()) {
1287 return true;
1288 }
1289 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1290 return false;
1291 }
1292 return false;
1293 }
1294
1295 static final private boolean jj_3R_196() {
1296 if (jj_3R_225()) {
1297 return true;
1298 }
1299 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1300 return false;
1301 }
1302 return false;
1303 }
1304
1305 static final private boolean jj_3_25() {
1306 if (jj_scan_token(LBRACKET)) {
1307 return true;
1308 }
1309 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1310 return false;
1311 }
1312 if (jj_scan_token(RBRACKET)) {
1313 return true;
1314 }
1315 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1316 return false;
1317 }
1318 return false;
1319 }
1320
1321 static final private boolean jj_3R_195() {
1322 if (jj_3R_224()) {
1323 return true;
1324 }
1325 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1326 return false;
1327 }
1328 return false;
1329 }
1330
1331 static final private boolean jj_3R_194() {
1332 if (jj_3R_223()) {
1333 return true;
1334 }
1335 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1336 return false;
1337 }
1338 return false;
1339 }
1340
1341 static final private boolean jj_3R_193() {
1342 if (jj_3R_222()) {
1343 return true;
1344 }
1345 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1346 return false;
1347 }
1348 return false;
1349 }
1350
1351 static final private boolean jj_3R_192() {
1352 if (jj_3R_221()) {
1353 return true;
1354 }
1355 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1356 return false;
1357 }
1358 return false;
1359 }
1360
1361 static final private boolean jj_3R_191() {
1362 if (jj_3R_220()) {
1363 return true;
1364 }
1365 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1366 return false;
1367 }
1368 return false;
1369 }
1370
1371 static final private boolean jj_3R_190() {
1372 if (jj_3R_219()) {
1373 return true;
1374 }
1375 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1376 return false;
1377 }
1378 return false;
1379 }
1380
1381 static final private boolean jj_3R_189() {
1382 if (jj_3R_218()) {
1383 return true;
1384 }
1385 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1386 return false;
1387 }
1388 return false;
1389 }
1390
1391 static final private boolean jj_3R_188() {
1392 if (jj_3R_217()) {
1393 return true;
1394 }
1395 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1396 return false;
1397 }
1398 return false;
1399 }
1400
1401 static final private boolean jj_3R_187() {
1402 if (jj_3R_216()) {
1403 return true;
1404 }
1405 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1406 return false;
1407 }
1408 return false;
1409 }
1410
1411 static final private boolean jj_3R_186() {
1412 if (jj_3R_215()) {
1413 return true;
1414 }
1415 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1416 return false;
1417 }
1418 return false;
1419 }
1420
1421 static final private boolean jj_3R_185() {
1422 if (jj_3R_214()) {
1423 return true;
1424 }
1425 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1426 return false;
1427 }
1428 if (jj_scan_token(SEMICOLON)) {
1429 return true;
1430 }
1431 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1432 return false;
1433 }
1434 return false;
1435 }
1436
1437 static final private boolean jj_3R_184() {
1438 if (jj_3R_213()) {
1439 return true;
1440 }
1441 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1442 return false;
1443 }
1444 return false;
1445 }
1446
1447 static final private boolean jj_3R_183() {
1448 if (jj_3R_70()) {
1449 return true;
1450 }
1451 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1452 return false;
1453 }
1454 return false;
1455 }
1456
1457 static final private boolean jj_3_27() {
1458 if (jj_3R_61()) {
1459 return true;
1460 }
1461 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1462 return false;
1463 }
1464 return false;
1465 }
1466
1467 static final private boolean jj_3R_174() {
1468 Token xsp;
1469
1470 xsp = jj_scanpos;
1471 if (jj_3_27()) {
1472 jj_scanpos = xsp;
1473 if (jj_3R_183()) {
1474 jj_scanpos = xsp;
1475 if (jj_3R_184()) {
1476 jj_scanpos = xsp;
1477 if (jj_3R_185()) {
1478 jj_scanpos = xsp;
1479 if (jj_3R_186()) {
1480 jj_scanpos = xsp;
1481 if (jj_3R_187()) {
1482 jj_scanpos = xsp;
1483 if (jj_3R_188()) {
1484 jj_scanpos = xsp;
1485 if (jj_3R_189()) {
1486 jj_scanpos = xsp;
1487 if (jj_3R_190()) {
1488 jj_scanpos = xsp;
1489 if (jj_3R_191()) {
1490 jj_scanpos = xsp;
1491 if (jj_3R_192()) {
1492 jj_scanpos = xsp;
1493 if (jj_3R_193()) {
1494 jj_scanpos = xsp;
1495 if (jj_3R_194()) {
1496 jj_scanpos = xsp;
1497 if (jj_3R_195()) {
1498 jj_scanpos = xsp;
1499 if (jj_3R_196()) {
1500 return true;
1501 }
1502 if (jj_la == 0
1503 && jj_scanpos
1504 == jj_lastpos) {
1505 return false;
1506 }
1507 } else if (jj_la
1508 == 0
1509 && jj_scanpos
1510 == jj_lastpos) {
1511 return false;
1512 }
1513 } else if (jj_la == 0
1514 && jj_scanpos
1515 == jj_lastpos) {
1516 return false;
1517 }
1518 } else if (jj_la == 0
1519 && jj_scanpos
1520 == jj_lastpos) {
1521 return false;
1522 }
1523 } else if (jj_la == 0
1524 && jj_scanpos
1525 == jj_lastpos) {
1526 return false;
1527 }
1528 } else if (jj_la == 0
1529 && jj_scanpos == jj_lastpos) {
1530 return false;
1531 }
1532 } else if (jj_la == 0
1533 && jj_scanpos == jj_lastpos) {
1534 return false;
1535 }
1536 } else if (jj_la == 0
1537 && jj_scanpos == jj_lastpos) {
1538 return false;
1539 }
1540 } else if (jj_la == 0
1541 && jj_scanpos == jj_lastpos) {
1542 return false;
1543 }
1544 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1545 return false;
1546 }
1547 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1548 return false;
1549 }
1550 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1551 return false;
1552 }
1553 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1554 return false;
1555 }
1556 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1557 return false;
1558 }
1559 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1560 return false;
1561 }
1562 return false;
1563 }
1564
1565 static final private boolean jj_3R_239() {
1566 if (jj_3R_243()) {
1567 return true;
1568 }
1569 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1570 return false;
1571 }
1572 return false;
1573 }
1574
1575 static final private boolean jj_3R_242() {
1576 if (jj_scan_token(LBRACKET)) {
1577 return true;
1578 }
1579 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1580 return false;
1581 }
1582 if (jj_scan_token(RBRACKET)) {
1583 return true;
1584 }
1585 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1586 return false;
1587 }
1588 return false;
1589 }
1590
1591 static final private boolean jj_3_24() {
1592 if (jj_scan_token(LBRACKET)) {
1593 return true;
1594 }
1595 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1596 return false;
1597 }
1598 if (jj_3R_60()) {
1599 return true;
1600 }
1601 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1602 return false;
1603 }
1604 if (jj_scan_token(RBRACKET)) {
1605 return true;
1606 }
1607 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1608 return false;
1609 }
1610 return false;
1611 }
1612
1613 static final private boolean jj_3R_238() {
1614 Token xsp;
1615
1616 if (jj_3R_242()) {
1617 return true;
1618 }
1619 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1620 return false;
1621 }
1622 while (true) {
1623 xsp = jj_scanpos;
1624 if (jj_3R_242()) {
1625 jj_scanpos = xsp;
1626 break;
1627 }
1628 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1629 return false;
1630 }
1631 }
1632 if (jj_3R_139()) {
1633 return true;
1634 }
1635 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1636 return false;
1637 }
1638 return false;
1639 }
1640
1641 static final private boolean jj_3_26() {
1642 Token xsp;
1643
1644 if (jj_3_24()) {
1645 return true;
1646 }
1647 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1648 return false;
1649 }
1650 while (true) {
1651 xsp = jj_scanpos;
1652 if (jj_3_24()) {
1653 jj_scanpos = xsp;
1654 break;
1655 }
1656 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1657 return false;
1658 }
1659 }
1660 while (true) {
1661 xsp = jj_scanpos;
1662 if (jj_3_25()) {
1663 jj_scanpos = xsp;
1664 break;
1665 }
1666 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1667 return false;
1668 }
1669 }
1670 return false;
1671 }
1672
1673 static final private boolean jj_3R_231() {
1674 Token xsp;
1675
1676 xsp = jj_scanpos;
1677 if (jj_3_26()) {
1678 jj_scanpos = xsp;
1679 if (jj_3R_238()) {
1680 return true;
1681 }
1682 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1683 return false;
1684 }
1685 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1686 return false;
1687 }
1688 return false;
1689 }
1690
1691 static final private boolean jj_3R_233() {
1692 if (jj_3R_54()) {
1693 return true;
1694 }
1695 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1696 return false;
1697 }
1698 Token xsp;
1699
1700 xsp = jj_scanpos;
1701 if (jj_3R_239()) {
1702 jj_scanpos = xsp;
1703 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1704 return false;
1705 }
1706 return false;
1707 }
1708
1709 static final private boolean jj_3R_159() {
1710 if (jj_scan_token(COMMA)) {
1711 return true;
1712 }
1713 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1714 return false;
1715 }
1716 if (jj_3R_60()) {
1717 return true;
1718 }
1719 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1720 return false;
1721 }
1722 return false;
1723 }
1724
1725 static final private boolean jj_3R_232() {
1726 if (jj_3R_231()) {
1727 return true;
1728 }
1729 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1730 return false;
1731 }
1732 return false;
1733 }
1734
1735 static final private boolean jj_3R_124() {
1736 if (jj_scan_token(NEW)) {
1737 return true;
1738 }
1739 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1740 return false;
1741 }
1742 if (jj_3R_47()) {
1743 return true;
1744 }
1745 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1746 return false;
1747 }
1748 Token xsp;
1749
1750 xsp = jj_scanpos;
1751 if (jj_3R_232()) {
1752 jj_scanpos = xsp;
1753 if (jj_3R_233()) {
1754 return true;
1755 }
1756 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1757 return false;
1758 }
1759 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1760 return false;
1761 }
1762 return false;
1763 }
1764
1765 static final private boolean jj_3_23() {
1766 if (jj_scan_token(NEW)) {
1767 return true;
1768 }
1769 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1770 return false;
1771 }
1772 if (jj_3R_56()) {
1773 return true;
1774 }
1775 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1776 return false;
1777 }
1778 if (jj_3R_231()) {
1779 return true;
1780 }
1781 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1782 return false;
1783 }
1784 return false;
1785 }
1786
1787 static final private boolean jj_3R_59() {
1788 Token xsp;
1789
1790 xsp = jj_scanpos;
1791 if (jj_3_23()) {
1792 jj_scanpos = xsp;
1793 if (jj_3R_124()) {
1794 return true;
1795 }
1796 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1797 return false;
1798 }
1799 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1800 return false;
1801 }
1802 return false;
1803 }
1804
1805 static final private boolean jj_3R_147() {
1806 if (jj_3R_60()) {
1807 return true;
1808 }
1809 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1810 return false;
1811 }
1812 Token xsp;
1813
1814 while (true) {
1815 xsp = jj_scanpos;
1816 if (jj_3R_159()) {
1817 jj_scanpos = xsp;
1818 break;
1819 }
1820 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1821 return false;
1822 }
1823 }
1824 return false;
1825 }
1826
1827 static final private boolean jj_3R_108() {
1828 if (jj_3R_147()) {
1829 return true;
1830 }
1831 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1832 return false;
1833 }
1834 return false;
1835 }
1836
1837 static final private boolean jj_3R_54() {
1838 if (jj_scan_token(LPAREN)) {
1839 return true;
1840 }
1841 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1842 return false;
1843 }
1844 Token xsp;
1845
1846 xsp = jj_scanpos;
1847 if (jj_3R_108()) {
1848 jj_scanpos = xsp;
1849 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1850 return false;
1851 }
1852 if (jj_scan_token(RPAREN)) {
1853 return true;
1854 }
1855 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1856 return false;
1857 }
1858 return false;
1859 }
1860
1861 static final private boolean jj_3R_178() {
1862 if (jj_scan_token(NULL)) {
1863 return true;
1864 }
1865 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1866 return false;
1867 }
1868 return false;
1869 }
1870
1871 static final private boolean jj_3R_198() {
1872 if (jj_scan_token(FALSE)) {
1873 return true;
1874 }
1875 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1876 return false;
1877 }
1878 return false;
1879 }
1880
1881 static final private boolean jj_3R_177() {
1882 Token xsp;
1883
1884 xsp = jj_scanpos;
1885 if (jj_3R_197()) {
1886 jj_scanpos = xsp;
1887 if (jj_3R_198()) {
1888 return true;
1889 }
1890 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1891 return false;
1892 }
1893 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1894 return false;
1895 }
1896 return false;
1897 }
1898
1899 static final private boolean jj_3R_197() {
1900 if (jj_scan_token(TRUE)) {
1901 return true;
1902 }
1903 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1904 return false;
1905 }
1906 return false;
1907 }
1908
1909 static final private boolean jj_3R_155() {
1910 if (jj_3R_158()) {
1911 return true;
1912 }
1913 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1914 return false;
1915 }
1916 return false;
1917 }
1918
1919 static final private boolean jj_3R_170() {
1920 if (jj_3R_178()) {
1921 return true;
1922 }
1923 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1924 return false;
1925 }
1926 return false;
1927 }
1928
1929 static final private boolean jj_3R_169() {
1930 if (jj_3R_177()) {
1931 return true;
1932 }
1933 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1934 return false;
1935 }
1936 return false;
1937 }
1938
1939 static final private boolean jj_3R_154() {
1940 if (jj_scan_token(NEW)) {
1941 return true;
1942 }
1943 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1944 return false;
1945 }
1946 return false;
1947 }
1948
1949 static final private boolean jj_3R_168() {
1950 if (jj_scan_token(STRING_LITERAL)) {
1951 return true;
1952 }
1953 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1954 return false;
1955 }
1956 return false;
1957 }
1958
1959 static final private boolean jj_3R_167() {
1960 if (jj_scan_token(CHARACTER_LITERAL)) {
1961 return true;
1962 }
1963 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1964 return false;
1965 }
1966 return false;
1967 }
1968
1969 static final private boolean jj_3R_166() {
1970 if (jj_scan_token(FLOATING_POINT_LITERAL)) {
1971 return true;
1972 }
1973 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1974 return false;
1975 }
1976 return false;
1977 }
1978
1979 static final private boolean jj_3R_158() {
1980 Token xsp;
1981
1982 xsp = jj_scanpos;
1983 if (jj_3R_165()) {
1984 jj_scanpos = xsp;
1985 if (jj_3R_166()) {
1986 jj_scanpos = xsp;
1987 if (jj_3R_167()) {
1988 jj_scanpos = xsp;
1989 if (jj_3R_168()) {
1990 jj_scanpos = xsp;
1991 if (jj_3R_169()) {
1992 jj_scanpos = xsp;
1993 if (jj_3R_170()) {
1994 return true;
1995 }
1996 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
1997 return false;
1998 }
1999 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2000 return false;
2001 }
2002 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2003 return false;
2004 }
2005 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2006 return false;
2007 }
2008 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2009 return false;
2010 }
2011 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2012 return false;
2013 }
2014 return false;
2015 }
2016
2017 static final private boolean jj_3R_165() {
2018 if (jj_scan_token(INTEGER_LITERAL)) {
2019 return true;
2020 }
2021 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2022 return false;
2023 }
2024 return false;
2025 }
2026
2027 static final private boolean jj_3R_153() {
2028 if (jj_scan_token(SUPER)) {
2029 return true;
2030 }
2031 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2032 return false;
2033 }
2034 return false;
2035 }
2036
2037 static final private boolean jj_3R_121() {
2038 if (jj_3R_54()) {
2039 return true;
2040 }
2041 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2042 return false;
2043 }
2044 return false;
2045 }
2046
2047 static final private boolean jj_3R_120() {
2048 if (jj_scan_token(DOT)) {
2049 return true;
2050 }
2051 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2052 return false;
2053 }
2054 if (jj_scan_token(IDENTIFIER)) {
2055 return true;
2056 }
2057 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2058 return false;
2059 }
2060 return false;
2061 }
2062
2063 static final private boolean jj_3R_119() {
2064 if (jj_scan_token(LBRACKET)) {
2065 return true;
2066 }
2067 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2068 return false;
2069 }
2070 if (jj_3R_60()) {
2071 return true;
2072 }
2073 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2074 return false;
2075 }
2076 if (jj_scan_token(RBRACKET)) {
2077 return true;
2078 }
2079 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2080 return false;
2081 }
2082 return false;
2083 }
2084
2085 static final private boolean jj_3R_152() {
2086 if (jj_scan_token(THIS)) {
2087 return true;
2088 }
2089 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2090 return false;
2091 }
2092 return false;
2093 }
2094
2095 static final private boolean jj_3_22() {
2096 if (jj_scan_token(DOT)) {
2097 return true;
2098 }
2099 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2100 return false;
2101 }
2102 if (jj_3R_59()) {
2103 return true;
2104 }
2105 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2106 return false;
2107 }
2108 return false;
2109 }
2110
2111 static final private boolean jj_3_20() {
2112 if (jj_3R_58()) {
2113 return true;
2114 }
2115 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2116 return false;
2117 }
2118 if (jj_scan_token(DOT)) {
2119 return true;
2120 }
2121 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2122 return false;
2123 }
2124 if (jj_scan_token(CLASS)) {
2125 return true;
2126 }
2127 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2128 return false;
2129 }
2130 return false;
2131 }
2132
2133 static final private boolean jj_3_21() {
2134 if (jj_scan_token(DOT)) {
2135 return true;
2136 }
2137 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2138 return false;
2139 }
2140 if (jj_scan_token(THIS)) {
2141 return true;
2142 }
2143 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2144 return false;
2145 }
2146 return false;
2147 }
2148
2149 static final private boolean jj_3R_57() {
2150 Token xsp;
2151
2152 xsp = jj_scanpos;
2153 if (jj_3_21()) {
2154 jj_scanpos = xsp;
2155 if (jj_3_22()) {
2156 jj_scanpos = xsp;
2157 if (jj_3R_119()) {
2158 jj_scanpos = xsp;
2159 if (jj_3R_120()) {
2160 jj_scanpos = xsp;
2161 if (jj_3R_121()) {
2162 return true;
2163 }
2164 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2165 return false;
2166 }
2167 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2168 return false;
2169 }
2170 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2171 return false;
2172 }
2173 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2174 return false;
2175 }
2176 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2177 return false;
2178 }
2179 return false;
2180 }
2181
2182 static final private boolean jj_3R_146() {
2183 if (jj_3R_47()) {
2184 return true;
2185 }
2186 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2187 return false;
2188 }
2189 return false;
2190 }
2191
2192 static final private boolean jj_3_19() {
2193 if (jj_3R_57()) {
2194 return true;
2195 }
2196 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2197 return false;
2198 }
2199 return false;
2200 }
2201
2202 static final private boolean jj_3R_145() {
2203 if (jj_3R_58()) {
2204 return true;
2205 }
2206 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2207 return false;
2208 }
2209 if (jj_scan_token(DOT)) {
2210 return true;
2211 }
2212 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2213 return false;
2214 }
2215 if (jj_scan_token(CLASS)) {
2216 return true;
2217 }
2218 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2219 return false;
2220 }
2221 return false;
2222 }
2223
2224 static final private boolean jj_3R_144() {
2225 if (jj_3R_59()) {
2226 return true;
2227 }
2228 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2229 return false;
2230 }
2231 return false;
2232 }
2233
2234 static final private boolean jj_3R_384() {
2235 if (jj_scan_token(DECR)) {
2236 return true;
2237 }
2238 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2239 return false;
2240 }
2241 return false;
2242 }
2243
2244 static final private boolean jj_3R_151() {
2245 if (jj_scan_token(IDENTIFIER)) {
2246 return true;
2247 }
2248 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2249 return false;
2250 }
2251 return false;
2252 }
2253
2254 static final private boolean jj_3R_143() {
2255 if (jj_scan_token(LPAREN)) {
2256 return true;
2257 }
2258 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2259 return false;
2260 }
2261 if (jj_3R_60()) {
2262 return true;
2263 }
2264 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2265 return false;
2266 }
2267 if (jj_scan_token(RPAREN)) {
2268 return true;
2269 }
2270 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2271 return false;
2272 }
2273 return false;
2274 }
2275
2276 static final private boolean jj_3R_142() {
2277 if (jj_scan_token(SUPER)) {
2278 return true;
2279 }
2280 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2281 return false;
2282 }
2283 if (jj_scan_token(DOT)) {
2284 return true;
2285 }
2286 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2287 return false;
2288 }
2289 if (jj_scan_token(IDENTIFIER)) {
2290 return true;
2291 }
2292 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2293 return false;
2294 }
2295 return false;
2296 }
2297
2298 static final private boolean jj_3R_141() {
2299 if (jj_scan_token(THIS)) {
2300 return true;
2301 }
2302 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2303 return false;
2304 }
2305 return false;
2306 }
2307
2308 static final private boolean jj_3R_150() {
2309 if (jj_scan_token(LPAREN)) {
2310 return true;
2311 }
2312 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2313 return false;
2314 }
2315 return false;
2316 }
2317
2318 static final private boolean jj_3R_383() {
2319 if (jj_scan_token(INCR)) {
2320 return true;
2321 }
2322 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2323 return false;
2324 }
2325 return false;
2326 }
2327
2328 static final private boolean jj_3R_377() {
2329 Token xsp;
2330
2331 xsp = jj_scanpos;
2332 if (jj_3R_383()) {
2333 jj_scanpos = xsp;
2334 if (jj_3R_384()) {
2335 return true;
2336 }
2337 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2338 return false;
2339 }
2340 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2341 return false;
2342 }
2343 return false;
2344 }
2345
2346 static final private boolean jj_3R_140() {
2347 if (jj_3R_158()) {
2348 return true;
2349 }
2350 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2351 return false;
2352 }
2353 return false;
2354 }
2355
2356 static final private boolean jj_3R_107() {
2357 Token xsp;
2358
2359 xsp = jj_scanpos;
2360 if (jj_3R_140()) {
2361 jj_scanpos = xsp;
2362 if (jj_3R_141()) {
2363 jj_scanpos = xsp;
2364 if (jj_3R_142()) {
2365 jj_scanpos = xsp;
2366 if (jj_3R_143()) {
2367 jj_scanpos = xsp;
2368 if (jj_3R_144()) {
2369 jj_scanpos = xsp;
2370 if (jj_3R_145()) {
2371 jj_scanpos = xsp;
2372 if (jj_3R_146()) {
2373 return true;
2374 }
2375 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2376 return false;
2377 }
2378 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2379 return false;
2380 }
2381 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2382 return false;
2383 }
2384 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2385 return false;
2386 }
2387 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2388 return false;
2389 }
2390 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2391 return false;
2392 }
2393 } else if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2394 return false;
2395 }
2396 return false;
2397 }
2398
2399 static final private boolean jj_3R_149() {
2400 if (jj_scan_token(BANG)) {
2401 return true;
2402 }
2403 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2404 return false;
2405 }
2406 return false;
2407 }
2408
2409 static final private boolean jj_3_18() {
2410 if (jj_scan_token(LPAREN)) {
2411 return true;
2412 }
2413 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2414 return false;
2415 }
2416 if (jj_3R_56()) {
2417 return true;
2418 }
2419 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2420 return false;
2421 }
2422 return false;
2423 }
2424
2425 static final private boolean jj_3R_53() {
2426 if (jj_3R_107()) {
2427 return true;
2428 }
2429 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2430 return false;
2431 }
2432 Token xsp;
2433
2434 while (true) {
2435 xsp = jj_scanpos;
2436 if (jj_3_19()) {
2437 jj_scanpos = xsp;
2438 break;
2439 }
2440 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2441 return false;
2442 }
2443 }
2444 return false;
2445 }
2446
2447 static final private boolean jj_3R_148() {
2448 if (jj_scan_token(TILDE)) {
2449 return true;
2450 }
2451 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2452 return false;
2453 }
2454 return false;
2455 }
2456
2457 static final private boolean jj_3R_365() {
2458 if (jj_scan_token(LPAREN)) {
2459 return true;
2460 }
2461 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2462 return false;
2463 }
2464 if (jj_3R_63()) {
2465 return true;
2466 }
2467 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2468 return false;
2469 }
2470 if (jj_scan_token(RPAREN)) {
2471 return true;
2472 }
2473 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2474 return false;
2475 }
2476 if (jj_3R_298()) {
2477 return true;
2478 }
2479 if (jj_la == 0 && jj_scanpos == jj_lastpos) {
2480 return false;
2481 }
2482 return false;
2483 }
2484 static private boolean jj_initialized_once = false;
2485 static public JavaParserTokenManager token_source;
2486 static JavaCharStream jj_input_stream;
2487 static public Token token, jj_nt;
2488 static private int jj_ntk;
2489 static private Token jj_scanpos, jj_lastpos;
2490 static private int jj_la;
2491 static public boolean lookingAhead = false;
2492 static private boolean jj_semLA;
2493 static private int jj_gen;
2494 static final private int[] jj_la1 = new int[112];
2495 static final private int[] jj_la1_0 = {0x0, 0x0, 0x20102000, 0x0, 0x2000,
2496 0x20002000, 0x20002000, 0x8000000, 0x0, 0xa2196000, 0x20002000,
2497 0x20002000, 0xa2094000, 0x20002000, 0x20002000, 0x2000, 0x2000,
2498 0x20002000, 0x20002000, 0x8000000, 0xa2196000, 0xa2094000, 0x20000000,
2499 0x20000000, 0x0, 0x0, 0x0, 0x92094000, 0x92094000, 0x0, 0x20002000,
2500 0x20002000, 0x0, 0x0, 0x0, 0x0, 0xa2094000, 0x20000000, 0x0, 0x0, 0x0,
2501 0xb359c000, 0x92094000, 0x0, 0x82094000, 0x0, 0x82094000, 0x82094000,
2502 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2503 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x92094000, 0x0, 0x0, 0x92094000,
2504 0x10000000, 0x0, 0x0, 0x0, 0x0, 0x10000000, 0x0, 0x0, 0x10000000,
2505 0x10000000, 0x92094000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9349c000,
2506 0xb359c000, 0x9359c000, 0x20000000, 0x0, 0x0, 0x0, 0x92094000, 0x820000,
2507 0xb359c000, 0x820000, 0x4000000, 0xb2094000, 0x92094000, 0x92094000,
2508 0x92094000, 0x0, 0x0, 0x0, 0x92094000, 0x40000, 0x40000000, };
2509 static final private int[] jj_la1_1 = {0x1000, 0x10, 0x80008080, 0x0,
2510 0x80008080, 0x80008000, 0x80008000, 0x0, 0x8, 0xb226e3c0, 0x8004e000,
2511 0x8004e000, 0x2206e140, 0x8024e200, 0x8024e200, 0x80008000, 0x80008000,
2512 0x8004e000, 0x8004e000, 0x0, 0xb226e3c0, 0x2206e140, 0x2204e000,
2513 0x2204e000, 0x0, 0x0, 0x0, 0x144a0d40, 0x144a0d40, 0x0, 0x8024e200,
2514 0x8024e200, 0x1000000, 0x0, 0x0, 0x0, 0x20140, 0x0, 0xe000, 0xe000,
2515 0x1000000, 0x5cfb0dc5, 0x144a0d40, 0x40000, 0x20140, 0x0, 0x20140,
2516 0x10020140, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20,
2517 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x144a0d40, 0x0, 0x0,
2518 0x144a0d40, 0x4480c00, 0x0, 0x0, 0x0, 0x0, 0x4480c00, 0x0, 0x0,
2519 0x4000800, 0x4000000, 0x144a0d40, 0x0, 0x0, 0x0, 0x400, 0x0, 0x0,
2520 0x5cfb0d45, 0x5cfb0dc5, 0x5cfb0dc5, 0x0, 0x0, 0x0, 0x0, 0x144a0d40, 0x0,
2521 0x5cfb0dc5, 0x0, 0x0, 0x144a0d40, 0x144a0d40, 0x144a0d40, 0x144a0d40,
2522 0x0, 0x0, 0x0, 0x144a0d40, 0x0, 0x0, };
2523 static final private int[] jj_la1_2 = {0x0, 0x0, 0x20000, 0x80000, 0x20000,
2524 0x0, 0x0, 0x0, 0x0, 0x2100, 0x0, 0x0, 0x100, 0x0, 0x0, 0x0, 0x0, 0x0,
2525 0x0, 0x0, 0x100, 0x100, 0x0, 0x0, 0x40000, 0x100000, 0x8000, 0x18029d1,
2526 0x18029d1, 0x40000, 0x0, 0x0, 0x0, 0x22000, 0x8000, 0x40000, 0x100, 0x0,
2527 0x0, 0x0, 0x0, 0x229d1, 0x9d1, 0x0, 0x100, 0x8000, 0x0, 0x100, 0x40000,
2528 0x100000, 0x100000, 0x2000000, 0x80000000, 0x0, 0x0, 0x0, 0x0,
2529 0x48000000, 0x48000000, 0x0, 0x30600000, 0x30600000, 0x0, 0x0, 0x0, 0x0,
2530 0x0, 0x0, 0x0, 0x18009d1, 0x1800000, 0x1800000, 0x9d1, 0x18009d1, 0x800,
2531 0x0, 0x0, 0x800, 0x8d1, 0x100, 0x88800, 0xd1, 0x0, 0x18009d1, 0x40000,
2532 0x2000, 0x8800, 0x0, 0x8000, 0x8000, 0x229d1, 0x229d1, 0x229d1, 0x0,
2533 0x40000, 0x100000, 0x100000, 0x9d1, 0x0, 0x229d1, 0x0, 0x0, 0x9d1,
2534 0x18009d1, 0x9d1, 0x9d1, 0x40000, 0x100, 0x100, 0x18009d1, 0x0, 0x0, };
2535 static final private int[] jj_la1_3 = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2536 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2537 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0x1e, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2538 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
2539 0x1ffc000, 0x1ffc000, 0x0, 0x0, 0x1, 0x100, 0x200, 0x80, 0x0, 0x0, 0x0,
2540 0x0, 0x0, 0x3800, 0x3800, 0x18, 0x18, 0x460, 0x460, 0x18, 0x1e, 0x0, 0x0,
2541 0x0, 0x0, 0x0, 0x6, 0x6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1e, 0x0, 0x0,
2542 0x0, 0x0, 0x0, 0x0, 0x6, 0x6, 0x6, 0x0, 0x0, 0x1ffc006, 0x1ffc006, 0x6,
2543 0x0, 0x6, 0x0, 0x0, 0x6, 0x1e, 0x6, 0x6, 0x0, 0x0, 0x0, 0x1e, 0x0, 0x0, };
2544 static final private JJCalls[] jj_2_rtns = new JJCalls[29];
2545 static private boolean jj_rescan = false;
2546 static private int jj_gc = 0;
2547 public JavaParser(java.io.InputStream stream) {
2548 if (jj_initialized_once) {
2549 System.out.println("ERROR: Second call to constructor of static parser. You must");
2550 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
2551 System.out.println(" during parser generation.");
2552 throw new Error ();
2553 }
2554 jj_initialized_once = true;
2555 jj_input_stream = new JavaCharStream(stream, 1, 1);
2556 token_source = new JavaParserTokenManager(jj_input_stream);
2557 token = new Token();
2558 jj_ntk = -1;
2559 jj_gen = 0;
2560 for (int i = 0; i < 112; i++) {
2561 jj_la1[i] = -1;
2562 }
2563 for (int i = 0; i < jj_2_rtns.length; i++) {
2564 jj_2_rtns[i] = new JJCalls();
2565 }
2566 }
2567
2568 static public void ReInit(java.io.InputStream stream) {
2569 jj_input_stream.ReInit(stream, 1, 1);
2570 token_source.ReInit(jj_input_stream);
2571 token = new Token();
2572 jj_ntk = -1;
2573 jjtree.reset();
2574 jj_gen = 0;
2575 for (int i = 0; i < 112; i++) {
2576 jj_la1[i] = -1;
2577 }
2578 for (int i = 0; i < jj_2_rtns.length; i++) {
2579 jj_2_rtns[i] = new JJCalls();
2580 }
2581 }
2582
2583 public JavaParser(java.io.Reader stream) {
2584 if (jj_initialized_once) {
2585 System.out.println("ERROR: Second call to constructor of static parser. You must");
2586 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
2587 System.out.println(" during parser generation.");
2588 throw new Error ();
2589 }
2590 jj_initialized_once = true;
2591 jj_input_stream = new JavaCharStream(stream, 1, 1);
2592 token_source = new JavaParserTokenManager(jj_input_stream);
2593 token = new Token();
2594 jj_ntk = -1;
2595 jj_gen = 0;
2596 for (int i = 0; i < 112; i++) {
2597 jj_la1[i] = -1;
2598 }
2599 for (int i = 0; i < jj_2_rtns.length; i++) {
2600 jj_2_rtns[i] = new JJCalls();
2601 }
2602 }
2603
2604 static public void ReInit(java.io.Reader stream) {
2605 jj_input_stream.ReInit(stream, 1, 1);
2606 token_source.ReInit(jj_input_stream);
2607 token = new Token();
2608 jj_ntk = -1;
2609 jjtree.reset();
2610 jj_gen = 0;
2611 for (int i = 0; i < 112; i++) {
2612 jj_la1[i] = -1;
2613 }
2614 for (int i = 0; i < jj_2_rtns.length; i++) {
2615 jj_2_rtns[i] = new JJCalls();
2616 }
2617 }
2618
2619 public JavaParser(JavaParserTokenManager tm) {
2620 if (jj_initialized_once) {
2621 System.out.println("ERROR: Second call to constructor of static parser. You must");
2622 System.out.println(" either use ReInit() or set the JavaCC option STATIC to false");
2623 System.out.println(" during parser generation.");
2624 throw new Error ();
2625 }
2626 jj_initialized_once = true;
2627 token_source = tm;
2628 token = new Token();
2629 jj_ntk = -1;
2630 jj_gen = 0;
2631 for (int i = 0; i < 112; i++) {
2632 jj_la1[i] = -1;
2633 }
2634 for (int i = 0; i < jj_2_rtns.length; i++) {
2635 jj_2_rtns[i] = new JJCalls();
2636 }
2637 }
2638
2639 public void ReInit(JavaParserTokenManager tm) {
2640 token_source = tm;
2641 token = new Token();
2642 jj_ntk = -1;
2643 jjtree.reset();
2644 jj_gen = 0;
2645 for (int i = 0; i < 112; i++) {
2646 jj_la1[i] = -1;
2647 }
2648 for (int i = 0; i < jj_2_rtns.length; i++) {
2649 jj_2_rtns[i] = new JJCalls();
2650 }
2651 }
2652
2653 static final private Token jj_consume_token(int kind) throws ParseException {
2654 Token oldToken;
2655
2656 if ((oldToken = token).next != null) {
2657 token = token.next;
2658 } else {
2659 token = token.next = token_source.getNextToken();
2660 }
2661 jj_ntk = -1;
2662 if (token.kind == kind) {
2663 jj_gen++;
2664 if (++jj_gc > 100) {
2665 jj_gc = 0;
2666 for (int i = 0; i < jj_2_rtns.length; i++) {
2667 JJCalls c = jj_2_rtns[i];
2668
2669 while (c != null) {
2670 if (c.gen < jj_gen) {
2671 c.first = null;
2672 }
2673 c = c.next;
2674 }
2675 }
2676 }
2677 return token;
2678 }
2679 token = oldToken;
2680 jj_kind = kind;
2681 throw generateParseException();
2682 }
2683
2684 static final private boolean jj_scan_token(int kind) {
2685 if (jj_scanpos == jj_lastpos) {
2686 jj_la--;
2687 if (jj_scanpos.next == null) {
2688 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
2689 } else {
2690 jj_lastpos = jj_scanpos = jj_scanpos.next;
2691 }
2692 } else {
2693 jj_scanpos = jj_scanpos.next;
2694 }
2695 if (jj_rescan) {
2696 int i = 0;
2697 Token tok = token;
2698
2699 while (tok != null && tok != jj_scanpos) {
2700 i++;
2701 tok = tok.next;
2702 }
2703 if (tok != null) {
2704 jj_add_error_token(kind, i);
2705 }
2706 }
2707 return (jj_scanpos.kind != kind);
2708 }
2709
2710 static final public Token getNextToken() {
2711 if (token.next != null) {
2712 token = token.next;
2713 } else {
2714 token = token.next = token_source.getNextToken();
2715 }
2716 jj_ntk = -1;
2717 jj_gen++;
2718 return token;
2719 }
2720
2721 static final public Token getToken(int index) {
2722 Token t = lookingAhead ? jj_scanpos : token;
2723
2724 for (int i = 0; i < index; i++) {
2725 if (t.next != null) {
2726 t = t.next;
2727 } else {
2728 t = t.next = token_source.getNextToken();
2729 }
2730 }
2731 return t;
2732 }
2733
2734 static final private int jj_ntk() {
2735 if ((jj_nt = token.next) == null) {
2736 return (jj_ntk = (token.next = token_source.getNextToken()).kind);
2737 } else {
2738 return (jj_ntk = jj_nt.kind);
2739 }
2740 }
2741 static private java.util.Vector jj_expentries = new java.util.Vector ();
2742 static private int[] jj_expentry;
2743 static private int jj_kind = -1;
2744 static private int[] jj_lasttokens = new int[100];
2745 static private int jj_endpos;
2746 static private void jj_add_error_token(int kind, int pos) {
2747 if (pos >= 100) {
2748 return;
2749 }
2750 if (pos == jj_endpos + 1) {
2751 jj_lasttokens[jj_endpos++] = kind;
2752 } else if (jj_endpos != 0) {
2753 jj_expentry = new int[jj_endpos];
2754 for (int i = 0; i < jj_endpos; i++) {
2755 jj_expentry[i] = jj_lasttokens[i];
2756 }
2757 boolean exists = false;
2758
2759 for (java.util.Enumeration tempEnum = jj_expentries.elements(); tempEnum.hasMoreElements();) {
2760 int[] oldentry = (int[]) (tempEnum.nextElement());
2761
2762 if (oldentry.length == jj_expentry.length) {
2763 exists = true;
2764 for (int i = 0; i < jj_expentry.length; i++) {
2765 if (oldentry[i] != jj_expentry[i]) {
2766 exists = false;
2767 break;
2768 }
2769 }
2770 if (exists) {
2771 break;
2772 }
2773 }
2774 }
2775 if (!exists) {
2776 jj_expentries.addElement(jj_expentry);
2777 }
2778 if (pos != 0) {
2779 jj_lasttokens[(jj_endpos = pos) - 1] = kind;
2780 }
2781 }
2782 }
2783
2784 static final public ParseException generateParseException() {
2785 jj_expentries.removeAllElements();
2786 boolean[] la1tokens = new boolean[121];
2787
2788 for (int i = 0; i < 121; i++) {
2789 la1tokens[i] = false;
2790 }
2791 if (jj_kind >= 0) {
2792 la1tokens[jj_kind] = true;
2793 jj_kind = -1;
2794 }
2795 for (int i = 0; i < 112; i++) {
2796 if (jj_la1[i] == jj_gen) {
2797 for (int j = 0; j < 32; j++) {
2798 if ((jj_la1_0[i] & (1 << j)) != 0) {
2799 la1tokens[j] = true;
2800 }
2801 if ((jj_la1_1[i] & (1 << j)) != 0) {
2802 la1tokens[32 + j] = true;
2803 }
2804 if ((jj_la1_2[i] & (1 << j)) != 0) {
2805 la1tokens[64 + j] = true;
2806 }
2807 if ((jj_la1_3[i] & (1 << j)) != 0) {
2808 la1tokens[96 + j] = true;
2809 }
2810 }
2811 }
2812 }
2813 for (int i = 0; i < 121; i++) {
2814 if (la1tokens[i]) {
2815 jj_expentry = new int[1];
2816 jj_expentry[0] = i;
2817 jj_expentries.addElement(jj_expentry);
2818 }
2819 }
2820 jj_endpos = 0;
2821 jj_rescan_token();
2822 jj_add_error_token(0, 0);
2823 int[][] exptokseq = new int[jj_expentries.size()][];
2824
2825 for (int i = 0; i < jj_expentries.size(); i++) {
2826 exptokseq[i] = (int[]) jj_expentries.elementAt(i);
2827 }
2828 return new ParseException(token, exptokseq, tokenImage);
2829 }
2830
2831 static final public void enable_tracing() {}
2832
2833 static final public void disable_tracing() {}
2834
2835 static final private void jj_rescan_token() {
2836 jj_rescan = true;
2837 for (int i = 0; i < 29; i++) {
2838 JJCalls p = jj_2_rtns[i];
2839
2840 do {
2841 if (p.gen > jj_gen) {
2842 jj_la = p.arg;
2843 jj_lastpos = jj_scanpos = p.first;
2844 switch (i) {
2845 case 0:
2846 jj_3_1();
2847 break;
2848
2849 case 1:
2850 jj_3_2();
2851 break;
2852
2853 case 2:
2854 jj_3_3();
2855 break;
2856
2857 case 3:
2858 jj_3_4();
2859 break;
2860
2861 case 4:
2862 jj_3_5();
2863 break;
2864
2865 case 5:
2866 jj_3_6();
2867 break;
2868
2869 case 6:
2870 jj_3_7();
2871 break;
2872
2873 case 7:
2874 jj_3_8();
2875 break;
2876
2877 case 8:
2878 jj_3_9();
2879 break;
2880
2881 case 9:
2882 jj_3_10();
2883 break;
2884
2885 case 10:
2886 jj_3_11();
2887 break;
2888
2889 case 11:
2890 jj_3_12();
2891 break;
2892
2893 case 12:
2894 jj_3_13();
2895 break;
2896
2897 case 13:
2898 jj_3_14();
2899 break;
2900
2901 case 14:
2902 jj_3_15();
2903 break;
2904
2905 case 15:
2906 jj_3_16();
2907 break;
2908
2909 case 16:
2910 jj_3_17();
2911 break;
2912
2913 case 17:
2914 jj_3_18();
2915 break;
2916
2917 case 18:
2918 jj_3_19();
2919 break;
2920
2921 case 19:
2922 jj_3_20();
2923 break;
2924
2925 case 20:
2926 jj_3_21();
2927 break;
2928
2929 case 21:
2930 jj_3_22();
2931 break;
2932
2933 case 22:
2934 jj_3_23();
2935 break;
2936
2937 case 23:
2938 jj_3_24();
2939 break;
2940
2941 case 24:
2942 jj_3_25();
2943 break;
2944
2945 case 25:
2946 jj_3_26();
2947 break;
2948
2949 case 26:
2950 jj_3_27();
2951 break;
2952
2953 case 27:
2954 jj_3_28();
2955 break;
2956
2957 case 28:
2958 jj_3_29();
2959 break;
2960 }
2961 }
2962 p = p.next;
2963 } while (p != null);
2964 }
2965 jj_rescan = false;
2966 }
2967
2968 static final private void jj_save(int index, int xla) {
2969 JJCalls p = jj_2_rtns[index];
2970
2971 while (p.gen > jj_gen) {
2972 if (p.next == null) {
2973 p = p.next = new JJCalls();
2974 break;
2975 }
2976 p = p.next;
2977 }
2978 p.gen = jj_gen + xla - jj_la;
2979 p.first = token;
2980 p.arg = xla;
2981 }
2982 static final class JJCalls {
2983 int gen;
2984 Token first;
2985 int arg;
2986 JJCalls next;
2987 }
2988}
2989 |
Popular Tags |
Java API By Example, From Geeks To Geeks.