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