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