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