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