Home | History | Annotate | Download | only in parser 
      1 /*
      2  * Copyright (C) 2011 Google Inc.
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  * http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.google.doclava.parser;
     18 
     19 import org.antlr.runtime.BaseRecognizer;
     20 import org.antlr.runtime.BitSet;
     21 import org.antlr.runtime.DFA;
     22 import org.antlr.runtime.EarlyExitException;
     23 import org.antlr.runtime.IntStream;
     24 import org.antlr.runtime.MismatchedSetException;
     25 import org.antlr.runtime.NoViableAltException;
     26 import org.antlr.runtime.RecognitionException;
     27 import org.antlr.runtime.RecognizerSharedState;
     28 import org.antlr.runtime.TokenStream;
     29 import org.antlr.runtime.debug.DebugEventListener;
     30 import org.antlr.runtime.debug.DebugEventSocketProxy;
     31 import org.antlr.runtime.debug.DebugParser;
     32 
     33 import java.io.IOException;
     34 import java.util.HashMap;
     35 /** A Java 1.5 grammar for ANTLR v3 derived from the spec
     36  *
     37  *  This is a very close representation of the spec; the changes
     38  *  are comestic (remove left recursion) and also fixes (the spec
     39  *  isn't exactly perfect).  I have run this on the 1.4.2 source
     40  *  and some nasty looking enums from 1.5, but have not really
     41  *  tested for 1.5 compatibility.
     42  *
     43  *  I built this with: java -Xmx100M org.antlr.Tool java.g
     44  *  and got two errors that are ok (for now):
     45  *  java.g:691:9: Decision can match input such as
     46  *    "'0'..'9'{'E', 'e'}{'+', '-'}'0'..'9'{'D', 'F', 'd', 'f'}"
     47  *    using multiple alternatives: 3, 4
     48  *  As a result, alternative(s) 4 were disabled for that input
     49  *  java.g:734:35: Decision can match input such as "{'$', 'A'..'Z',
     50  *    '_', 'a'..'z', '\u00C0'..'\u00D6', '\u00D8'..'\u00F6',
     51  *    '\u00F8'..'\u1FFF', '\u3040'..'\u318F', '\u3300'..'\u337F',
     52  *    '\u3400'..'\u3D2D', '\u4E00'..'\u9FFF', '\uF900'..'\uFAFF'}"
     53  *    using multiple alternatives: 1, 2
     54  *  As a result, alternative(s) 2 were disabled for that input
     55  *
     56  *  You can turn enum on/off as a keyword :)
     57  *
     58  *  Version 1.0 -- initial release July 5, 2006 (requires 3.0b2 or higher)
     59  *
     60  *  Primary author: Terence Parr, July 2006
     61  *
     62  *  Version 1.0.1 -- corrections by Koen Vanderkimpen & Marko van Dooren,
     63  *      October 25, 2006;
     64  *      fixed normalInterfaceDeclaration: now uses typeParameters instead
     65  *          of typeParameter (according to JLS, 3rd edition)
     66  *      fixed castExpression: no longer allows expression next to type
     67  *          (according to semantics in JLS, in contrast with syntax in JLS)
     68  *
     69  *  Version 1.0.2 -- Terence Parr, Nov 27, 2006
     70  *      java spec I built this from had some bizarre for-loop control.
     71  *          Looked weird and so I looked elsewhere...Yep, it's messed up.
     72  *          simplified.
     73  *
     74  *  Version 1.0.3 -- Chris Hogue, Feb 26, 2007
     75  *      Factored out an annotationName rule and used it in the annotation rule.
     76  *          Not sure why, but typeName wasn't recognizing references to inner
     77  *          annotations (e.g. @InterfaceName.InnerAnnotation())
     78  *      Factored out the elementValue section of an annotation reference.  Created
     79  *          elementValuePair and elementValuePairs rules, then used them in the
     80  *          annotation rule.  Allows it to recognize annotation references with
     81  *          multiple, comma separated attributes.
     82  *      Updated elementValueArrayInitializer so that it allows multiple elements.
     83  *          (It was only allowing 0 or 1 element).
     84  *      Updated localVariableDeclaration to allow annotations.  Interestingly the JLS
     85  *          doesn't appear to indicate this is legal, but it does work as of at least
     86  *          JDK 1.5.0_06.
     87  *      Moved the Identifier portion of annotationTypeElementRest to annotationMethodRest.
     88  *          Because annotationConstantRest already references variableDeclarator which
     89  *          has the Identifier portion in it, the parser would fail on constants in
     90  *          annotation definitions because it expected two identifiers.
     91  *      Added optional trailing ';' to the alternatives in annotationTypeElementRest.
     92  *          Wouldn't handle an inner interface that has a trailing ';'.
     93  *      Swapped the expression and type rule reference order in castExpression to
     94  *          make it check for genericized casts first.  It was failing to recognize a
     95  *          statement like  "Class<Byte> TYPE = (Class<Byte>)...;" because it was seeing
     96  *          'Class<Byte' in the cast expression as a less than expression, then failing
     97  *          on the '>'.
     98  *      Changed createdName to use typeArguments instead of nonWildcardTypeArguments.
     99  *
    100  *      Changed the 'this' alternative in primary to allow 'identifierSuffix' rather than
    101  *          just 'arguments'.  The case it couldn't handle was a call to an explicit
    102  *          generic method invocation (e.g. this.<E>doSomething()).  Using identifierSuffix
    103  *          may be overly aggressive--perhaps should create a more constrained thisSuffix rule?
    104  *
    105  *  Version 1.0.4 -- Hiroaki Nakamura, May 3, 2007
    106  *
    107  *  Fixed formalParameterDecls, localVariableDeclaration, forInit,
    108  *  and forVarControl to use variableModifier* not 'final'? (annotation)?
    109  *
    110  *  Version 1.0.5 -- Terence, June 21, 2007
    111  *  --a[i].foo didn't work. Fixed unaryExpression
    112  *
    113  *  Version 1.0.6 -- John Ridgway, March 17, 2008
    114  *      Made "assert" a switchable keyword like "enum".
    115  *      Fixed compilationUnit to disallow "annotation importDeclaration ...".
    116  *      Changed "Identifier ('.' Identifier)*" to "qualifiedName" in more
    117  *          places.
    118  *      Changed modifier* and/or variableModifier* to classOrInterfaceModifiers,
    119  *          modifiers or variableModifiers, as appropriate.
    120  *      Renamed "bound" to "typeBound" to better match language in the JLS.
    121  *      Added "memberDeclaration" which rewrites to methodDeclaration or
    122  *      fieldDeclaration and pulled type into memberDeclaration.  So we parse
    123  *          type and then move on to decide whether we're dealing with a field
    124  *          or a method.
    125  *      Modified "constructorDeclaration" to use "constructorBody" instead of
    126  *          "methodBody".  constructorBody starts with explicitConstructorInvocation,
    127  *          then goes on to blockStatement*.  Pulling explicitConstructorInvocation
    128  *          out of expressions allowed me to simplify "primary".
    129  *      Changed variableDeclarator to simplify it.
    130  *      Changed type to use classOrInterfaceType, thus simplifying it; of course
    131  *          I then had to add classOrInterfaceType, but it is used in several
    132  *          places.
    133  *      Fixed annotations, old version allowed "@X(y,z)", which is illegal.
    134  *      Added optional comma to end of "elementValueArrayInitializer"; as per JLS.
    135  *      Changed annotationTypeElementRest to use normalClassDeclaration and
    136  *          normalInterfaceDeclaration rather than classDeclaration and
    137  *          interfaceDeclaration, thus getting rid of a couple of grammar ambiguities.
    138  *      Split localVariableDeclaration into localVariableDeclarationStatement
    139  *          (includes the terminating semi-colon) and localVariableDeclaration.
    140  *          This allowed me to use localVariableDeclaration in "forInit" clauses,
    141  *           simplifying them.
    142  *      Changed switchBlockStatementGroup to use multiple labels.  This adds an
    143  *          ambiguity, but if one uses appropriately greedy parsing it yields the
    144  *           parse that is closest to the meaning of the switch statement.
    145  *      Renamed "forVarControl" to "enhancedForControl" -- JLS language.
    146  *      Added semantic predicates to test for shift operations rather than other
    147  *          things.  Thus, for instance, the string "< <" will never be treated
    148  *          as a left-shift operator.
    149  *      In "creator" we rule out "nonWildcardTypeArguments" on arrayCreation,
    150  *          which are illegal.
    151  *      Moved "nonWildcardTypeArguments into innerCreator.
    152  *      Removed 'super' superSuffix from explicitGenericInvocation, since that
    153  *          is only used in explicitConstructorInvocation at the beginning of a
    154  *           constructorBody.  (This is part of the simplification of expressions
    155  *           mentioned earlier.)
    156  *      Simplified primary (got rid of those things that are only used in
    157  *          explicitConstructorInvocation).
    158  *      Lexer -- removed "Exponent?" from FloatingPointLiteral choice 4, since it
    159  *          led to an ambiguity.
    160  *
    161  *      This grammar successfully parses every .java file in the JDK 1.5 source
    162  *          tree (excluding those whose file names include '-', which are not
    163  *          valid Java compilation units).
    164  *
    165  *  Known remaining problems:
    166  *      "Letter" and "JavaIDDigit" are wrong.  The actual specification of
    167  *      "Letter" should be "a character for which the method
    168  *      Character.isJavaIdentifierStart(int) returns true."  A "Java
    169  *      letter-or-digit is a character for which the method
    170  *      Character.isJavaIdentifierPart(int) returns true."
    171  */
    172 public class JavaParser extends DebugParser {
    173     public static final String[] tokenNames = new String[] {
    174         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "IDENTIFIER", "INTLITERAL", "LONGLITERAL", "FLOATLITERAL", "DOUBLELITERAL", "CHARLITERAL", "STRINGLITERAL", "TRUE", "FALSE", "NULL", "IntegerNumber", "LongSuffix", "HexPrefix", "HexDigit", "Exponent", "NonIntegerNumber", "FloatSuffix", "DoubleSuffix", "EscapeSequence", "UNICODECHAR", "UNICODEPART", "WS", "COMMENT", "LINE_COMMENT", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "GOTO", "IF", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", "SEMI", "COMMA", "DOT", "ELLIPSIS", "EQ", "BANG", "TILDE", "QUES", "COLON", "EQEQ", "AMPAMP", "BARBAR", "PLUSPLUS", "SUBSUB", "PLUS", "SUB", "STAR", "SLASH", "AMP", "BAR", "CARET", "PERCENT", "PLUSEQ", "SUBEQ", "STAREQ", "SLASHEQ", "AMPEQ", "BAREQ", "CARETEQ", "PERCENTEQ", "MONKEYS_AT", "BANGEQ", "GT", "LT", "IdentifierStart", "IdentifierPart", "SurrogateIdentifer"
    175     };
    176     public static final int EOF=-1;
    177     public static final int IDENTIFIER=4;
    178     public static final int INTLITERAL=5;
    179     public static final int LONGLITERAL=6;
    180     public static final int FLOATLITERAL=7;
    181     public static final int DOUBLELITERAL=8;
    182     public static final int CHARLITERAL=9;
    183     public static final int STRINGLITERAL=10;
    184     public static final int TRUE=11;
    185     public static final int FALSE=12;
    186     public static final int NULL=13;
    187     public static final int IntegerNumber=14;
    188     public static final int LongSuffix=15;
    189     public static final int HexPrefix=16;
    190     public static final int HexDigit=17;
    191     public static final int Exponent=18;
    192     public static final int NonIntegerNumber=19;
    193     public static final int FloatSuffix=20;
    194     public static final int DoubleSuffix=21;
    195     public static final int EscapeSequence=22;
    196     public static final int UNICODECHAR=23;
    197     public static final int UNICODEPART=24;
    198     public static final int WS=25;
    199     public static final int COMMENT=26;
    200     public static final int LINE_COMMENT=27;
    201     public static final int ABSTRACT=28;
    202     public static final int ASSERT=29;
    203     public static final int BOOLEAN=30;
    204     public static final int BREAK=31;
    205     public static final int BYTE=32;
    206     public static final int CASE=33;
    207     public static final int CATCH=34;
    208     public static final int CHAR=35;
    209     public static final int CLASS=36;
    210     public static final int CONST=37;
    211     public static final int CONTINUE=38;
    212     public static final int DEFAULT=39;
    213     public static final int DO=40;
    214     public static final int DOUBLE=41;
    215     public static final int ELSE=42;
    216     public static final int ENUM=43;
    217     public static final int EXTENDS=44;
    218     public static final int FINAL=45;
    219     public static final int FINALLY=46;
    220     public static final int FLOAT=47;
    221     public static final int FOR=48;
    222     public static final int GOTO=49;
    223     public static final int IF=50;
    224     public static final int IMPLEMENTS=51;
    225     public static final int IMPORT=52;
    226     public static final int INSTANCEOF=53;
    227     public static final int INT=54;
    228     public static final int INTERFACE=55;
    229     public static final int LONG=56;
    230     public static final int NATIVE=57;
    231     public static final int NEW=58;
    232     public static final int PACKAGE=59;
    233     public static final int PRIVATE=60;
    234     public static final int PROTECTED=61;
    235     public static final int PUBLIC=62;
    236     public static final int RETURN=63;
    237     public static final int SHORT=64;
    238     public static final int STATIC=65;
    239     public static final int STRICTFP=66;
    240     public static final int SUPER=67;
    241     public static final int SWITCH=68;
    242     public static final int SYNCHRONIZED=69;
    243     public static final int THIS=70;
    244     public static final int THROW=71;
    245     public static final int THROWS=72;
    246     public static final int TRANSIENT=73;
    247     public static final int TRY=74;
    248     public static final int VOID=75;
    249     public static final int VOLATILE=76;
    250     public static final int WHILE=77;
    251     public static final int LPAREN=78;
    252     public static final int RPAREN=79;
    253     public static final int LBRACE=80;
    254     public static final int RBRACE=81;
    255     public static final int LBRACKET=82;
    256     public static final int RBRACKET=83;
    257     public static final int SEMI=84;
    258     public static final int COMMA=85;
    259     public static final int DOT=86;
    260     public static final int ELLIPSIS=87;
    261     public static final int EQ=88;
    262     public static final int BANG=89;
    263     public static final int TILDE=90;
    264     public static final int QUES=91;
    265     public static final int COLON=92;
    266     public static final int EQEQ=93;
    267     public static final int AMPAMP=94;
    268     public static final int BARBAR=95;
    269     public static final int PLUSPLUS=96;
    270     public static final int SUBSUB=97;
    271     public static final int PLUS=98;
    272     public static final int SUB=99;
    273     public static final int STAR=100;
    274     public static final int SLASH=101;
    275     public static final int AMP=102;
    276     public static final int BAR=103;
    277     public static final int CARET=104;
    278     public static final int PERCENT=105;
    279     public static final int PLUSEQ=106;
    280     public static final int SUBEQ=107;
    281     public static final int STAREQ=108;
    282     public static final int SLASHEQ=109;
    283     public static final int AMPEQ=110;
    284     public static final int BAREQ=111;
    285     public static final int CARETEQ=112;
    286     public static final int PERCENTEQ=113;
    287     public static final int MONKEYS_AT=114;
    288     public static final int BANGEQ=115;
    289     public static final int GT=116;
    290     public static final int LT=117;
    291     public static final int IdentifierStart=118;
    292     public static final int IdentifierPart=119;
    293     public static final int SurrogateIdentifer=120;
    294 
    295     // delegates
    296     // delegators
    297 
    298     public static final String[] ruleNames = new String[] {
    299         "invalidRule", "typeList", "synpred114_Java", "synpred175_Java",
    300         "synpred19_Java", "elementValuePairs", "identifierSuffix", "interfaceFieldDeclaration",
    301         "synpred69_Java", "synpred263_Java", "synpred231_Java", "synpred267_Java",
    302         "synpred111_Java", "block", "synpred261_Java", "elementValuePair",
    303         "typeArgument", "synpred264_Java", "synpred95_Java", "synpred93_Java",
    304         "synpred215_Java", "normalInterfaceDeclaration", "enumHeader", "synpred236_Java",
    305         "createdName", "synpred271_Java", "synpred230_Java", "synpred30_Java",
    306         "synpred212_Java", "synpred82_Java", "synpred128_Java", "synpred83_Java",
    307         "synpred255_Java", "synpred190_Java", "arrayInitializer", "interfaceDeclaration",
    308         "synpred92_Java", "localVariableHeader", "packageDeclaration", "formalParameter",
    309         "catchClause", "synpred27_Java", "synpred270_Java", "synpred46_Java",
    310         "synpred1_Java", "synpred4_Java", "synpred233_Java", "synpred120_Java",
    311         "superSuffix", "literal", "classDeclaration", "synpred72_Java",
    312         "synpred160_Java", "arguments", "synpred80_Java", "formalParameterDecls",
    313         "synpred113_Java", "inclusiveOrExpression", "synpred71_Java", "selector",
    314         "synpred194_Java", "synpred265_Java", "synpred173_Java", "synpred141_Java",
    315         "synpred187_Java", "trystatement", "synpred133_Java", "interfaceHeader",
    316         "synpred73_Java", "localVariableDeclarationStatement", "synpred102_Java",
    317         "synpred90_Java", "equalityExpression", "synpred177_Java", "synpred149_Java",
    318         "interfaceBodyDeclaration", "classCreatorRest", "synpred121_Java",
    319         "synpred105_Java", "typeArguments", "synpred60_Java", "synpred195_Java",
    320         "fieldDeclaration", "synpred269_Java", "synpred250_Java", "multiplicativeExpression",
    321         "qualifiedNameList", "synpred86_Java", "synpred148_Java", "synpred142_Java",
    322         "synpred65_Java", "synpred75_Java", "synpred235_Java", "synpred192_Java",
    323         "synpred144_Java", "castExpression", "enumBody", "synpred70_Java",
    324         "synpred33_Java", "synpred54_Java", "annotationTypeDeclaration",
    325         "annotationHeader", "synpred107_Java", "synpred35_Java", "creator",
    326         "nonWildcardTypeArguments", "variableInitializer", "enumConstants",
    327         "synpred34_Java", "interfaceMethodDeclaration", "type", "synpred135_Java",
    328         "synpred119_Java", "conditionalAndExpression", "synpred9_Java",
    329         "synpred125_Java", "synpred40_Java", "synpred257_Java", "enumConstant",
    330         "synpred143_Java", "synpred132_Java", "synpred146_Java", "synpred188_Java",
    331         "ellipsisParameterDecl", "synpred245_Java", "synpred167_Java", "compilationUnit",
    332         "synpred259_Java", "synpred64_Java", "synpred181_Java", "synpred23_Java",
    333         "synpred12_Java", "synpred74_Java", "explicitConstructorInvocation",
    334         "synpred266_Java", "synpred197_Java", "synpred147_Java", "synpred15_Java",
    335         "synpred178_Java", "synpred174_Java", "exclusiveOrExpression", "forstatement",
    336         "synpred7_Java", "synpred76_Java", "synpred224_Java", "parExpression",
    337         "synpred241_Java", "synpred159_Java", "synpred260_Java", "synpred50_Java",
    338         "synpred166_Java", "annotationMethodDeclaration", "synpred208_Java",
    339         "synpred106_Java", "classOrInterfaceType", "qualifiedImportName",
    340         "statement", "typeBound", "methodHeader", "synpred249_Java", "synpred55_Java",
    341         "synpred131_Java", "classBodyDeclaration", "synpred189_Java", "synpred51_Java",
    342         "synpred227_Java", "synpred220_Java", "synpred123_Java", "andExpression",
    343         "synpred200_Java", "synpred165_Java", "relationalExpression", "annotationTypeBody",
    344         "synpred210_Java", "synpred109_Java", "conditionalOrExpression",
    345         "synpred161_Java", "classOrInterfaceDeclaration", "synpred180_Java",
    346         "synpred154_Java", "elementValueArrayInitializer", "synpred14_Java",
    347         "innerCreator", "synpred26_Java", "synpred52_Java", "synpred198_Java",
    348         "synpred219_Java", "synpred126_Java", "synpred85_Java", "synpred88_Java",
    349         "synpred68_Java", "synpred3_Java", "synpred203_Java", "annotations",
    350         "elementValue", "synpred205_Java", "synpred6_Java", "synpred32_Java",
    351         "synpred209_Java", "assignmentOperator", "synpred262_Java", "synpred139_Java",
    352         "synpred29_Java", "synpred204_Java", "synpred118_Java", "synpred94_Java",
    353         "synpred84_Java", "synpred63_Java", "conditionalExpression", "synpred56_Java",
    354         "synpred162_Java", "primitiveType", "synpred240_Java", "synpred216_Java",
    355         "synpred79_Java", "synpred99_Java", "additiveExpression", "synpred78_Java",
    356         "modifiers", "synpred184_Java", "synpred168_Java", "synpred48_Java",
    357         "switchBlockStatementGroups", "blockStatement", "synpred193_Java",
    358         "classBody", "interfaceBody", "synpred67_Java", "synpred5_Java",
    359         "synpred58_Java", "synpred254_Java", "localVariableDeclaration",
    360         "annotationTypeElementDeclaration", "synpred251_Java", "arrayCreator",
    361         "synpred226_Java", "synpred239_Java", "synpred191_Java", "synpred24_Java",
    362         "normalClassDeclaration", "synpred98_Java", "synpred53_Java", "synpred145_Java",
    363         "synpred22_Java", "synpred150_Java", "synpred238_Java", "synpred207_Java",
    364         "variableModifiers", "typeParameters", "synpred38_Java", "synpred129_Java",
    365         "enumBodyDeclarations", "synpred172_Java", "synpred16_Java", "synpred100_Java",
    366         "fieldHeader", "synpred41_Java", "synpred248_Java", "synpred152_Java",
    367         "synpred214_Java", "switchBlockStatementGroup", "synpred199_Java",
    368         "switchLabel", "qualifiedName", "synpred137_Java", "synpred237_Java",
    369         "synpred223_Java", "synpred156_Java", "synpred243_Java", "synpred182_Java",
    370         "synpred138_Java", "synpred77_Java", "synpred127_Java", "synpred112_Java",
    371         "unaryExpressionNotPlusMinus", "synpred42_Java", "synpred89_Java",
    372         "formalParameters", "synpred225_Java", "synpred136_Java", "synpred186_Java",
    373         "synpred122_Java", "synpred87_Java", "synpred244_Java", "synpred97_Java",
    374         "synpred229_Java", "synpred170_Java", "shiftOp", "synpred134_Java",
    375         "synpred253_Java", "synpred44_Java", "memberDecl", "synpred157_Java",
    376         "synpred246_Java", "synpred49_Java", "synpred31_Java", "synpred256_Java",
    377         "unaryExpression", "synpred13_Java", "synpred213_Java", "synpred155_Java",
    378         "typeHeader", "synpred91_Java", "instanceOfExpression", "variableDeclarator",
    379         "synpred140_Java", "synpred25_Java", "synpred117_Java", "synpred2_Java",
    380         "synpred222_Java", "synpred10_Java", "synpred104_Java", "synpred115_Java",
    381         "synpred221_Java", "synpred45_Java", "synpred211_Java", "typeParameter",
    382         "synpred36_Java", "synpred103_Java", "synpred39_Java", "synpred201_Java",
    383         "methodDeclaration", "synpred62_Java", "synpred110_Java", "classHeader",
    384         "synpred101_Java", "synpred21_Java", "synpred196_Java", "synpred96_Java",
    385         "synpred61_Java", "synpred228_Java", "synpred28_Java", "synpred218_Java",
    386         "synpred179_Java", "normalParameterDecl", "enumDeclaration", "synpred17_Java",
    387         "synpred18_Java", "synpred108_Java", "synpred43_Java", "synpred206_Java",
    388         "synpred169_Java", "synpred130_Java", "synpred242_Java", "synpred252_Java",
    389         "synpred151_Java", "forInit", "shiftExpression", "synpred81_Java",
    390         "synpred247_Java", "synpred20_Java", "catches", "synpred202_Java",
    391         "synpred47_Java", "synpred185_Java", "synpred158_Java", "synpred66_Java",
    392         "synpred11_Java", "synpred8_Java", "synpred163_Java", "synpred217_Java",
    393         "primary", "synpred153_Java", "synpred57_Java", "synpred258_Java",
    394         "expressionList", "annotation", "expression", "synpred176_Java",
    395         "synpred171_Java", "synpred164_Java", "importDeclaration", "synpred124_Java",
    396         "synpred268_Java", "synpred234_Java", "relationalOp", "synpred59_Java",
    397         "synpred37_Java", "synpred183_Java", "synpred232_Java", "synpred116_Java",
    398         "typeDeclaration"
    399     };
    400     public static final boolean[] decisionCanBacktrack = new boolean[] {
    401         false, // invalid decision
    402         false, true, false, false, false, false, false, false, false, false,
    403             false, true, false, false, true, false, false, false, false,
    404             false, false, false, false, false, false, false, false, false,
    405             false, false, true, false, false, false, false, false, false,
    406             false, true, false, false, true, false, false, false, false,
    407             false, false, true, false, false, false, true, false, false,
    408             false, false, false, false, false, false, false, false, false,
    409             false, false, false, false, false, false, true, true, false,
    410             false, false, true, false, false, false, false, false, false,
    411             false, false, false, false, true, false, false, true, false,
    412             false, false, true, false, false, false, true, false, false,
    413             false, true, false, false, false, false, false, true, true,
    414             false, false, false, false, false, false, false, false, false,
    415             false, false, false, false, false, false, false, false, false,
    416             false, false, true, true, true, true, true, true, false, false,
    417             false, false, false, false, true, false, false, false, true,
    418             false, true, false, true, false, false, false, false, false,
    419             false, false, false, false, false, false, false, false, false,
    420             false, false, false, false, false, false, true, false, false,
    421             false, false, false, false, false, false, false, false, false,
    422             false, false, false, false, false, false, false, false, false,
    423             false, false, false
    424     };
    425 
    426 
    427         public int ruleLevel = 0;
    428         public int getRuleLevel() { return ruleLevel; }
    429         public void incRuleLevel() { ruleLevel++; }
    430         public void decRuleLevel() { ruleLevel--; }
    431         public JavaParser(TokenStream input) {
    432             this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
    433         }
    434         public JavaParser(TokenStream input, int port, RecognizerSharedState state) {
    435             super(input, state);
    436             this.state.ruleMemo = new HashMap[381+1];
    437 
    438             DebugEventSocketProxy proxy =
    439                 new DebugEventSocketProxy(this, port, null);
    440             setDebugListener(proxy);
    441             try {
    442                 proxy.handshake();
    443             }
    444             catch (IOException ioe) {
    445                 reportError(ioe);
    446             }
    447         }
    448     public JavaParser(TokenStream input, DebugEventListener dbg) {
    449         super(input, dbg, new RecognizerSharedState());
    450         this.state.ruleMemo = new HashMap[381+1];
    451 
    452     }
    453     protected boolean evalPredicate(boolean result, String predicate) {
    454         dbg.semanticPredicate(result, predicate);
    455         return result;
    456     }
    457 
    458 
    459     public String[] getTokenNames() { return JavaParser.tokenNames; }
    460     public String getGrammarFileName() { return "src/com/google/doclava/parser/Java.g"; }
    461 
    462 
    463 
    464     // $ANTLR start "compilationUnit"
    465     // src/com/google/doclava/parser/Java.g:293:1: compilationUnit : ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ;
    466     public final void compilationUnit() throws RecognitionException {
    467         int compilationUnit_StartIndex = input.index();
    468         try { dbg.enterRule(getGrammarFileName(), "compilationUnit");
    469         if ( getRuleLevel()==0 ) {dbg.commence();}
    470         incRuleLevel();
    471         dbg.location(293, 1);
    472 
    473         try {
    474             if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return ; }
    475             // src/com/google/doclava/parser/Java.g:298:5: ( ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* )
    476             dbg.enterAlt(1);
    477 
    478             // src/com/google/doclava/parser/Java.g:298:9: ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )*
    479             {
    480             dbg.location(298,9);
    481             // src/com/google/doclava/parser/Java.g:298:9: ( ( annotations )? packageDeclaration )?
    482             int alt2=2;
    483             try { dbg.enterSubRule(2);
    484             try { dbg.enterDecision(2, decisionCanBacktrack[2]);
    485 
    486             try {
    487                 isCyclicDecision = true;
    488                 alt2 = dfa2.predict(input);
    489             }
    490             catch (NoViableAltException nvae) {
    491                 dbg.recognitionException(nvae);
    492                 throw nvae;
    493             }
    494             } finally {dbg.exitDecision(2);}
    495 
    496             switch (alt2) {
    497                 case 1 :
    498                     dbg.enterAlt(1);
    499 
    500                     // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? packageDeclaration
    501                     {
    502                     dbg.location(298,13);
    503                     // src/com/google/doclava/parser/Java.g:298:13: ( annotations )?
    504                     int alt1=2;
    505                     try { dbg.enterSubRule(1);
    506                     try { dbg.enterDecision(1, decisionCanBacktrack[1]);
    507 
    508                     int LA1_0 = input.LA(1);
    509 
    510                     if ( (LA1_0==MONKEYS_AT) ) {
    511                         alt1=1;
    512                     }
    513                     } finally {dbg.exitDecision(1);}
    514 
    515                     switch (alt1) {
    516                         case 1 :
    517                             dbg.enterAlt(1);
    518 
    519                             // src/com/google/doclava/parser/Java.g:298:14: annotations
    520                             {
    521                             dbg.location(298,14);
    522                             pushFollow(FOLLOW_annotations_in_compilationUnit64);
    523                             annotations();
    524 
    525                             state._fsp--;
    526                             if (state.failed) return ;
    527 
    528                             }
    529                             break;
    530 
    531                     }
    532                     } finally {dbg.exitSubRule(1);}
    533 
    534                     dbg.location(300,13);
    535                     pushFollow(FOLLOW_packageDeclaration_in_compilationUnit93);
    536                     packageDeclaration();
    537 
    538                     state._fsp--;
    539                     if (state.failed) return ;
    540 
    541                     }
    542                     break;
    543 
    544             }
    545             } finally {dbg.exitSubRule(2);}
    546 
    547             dbg.location(302,9);
    548             // src/com/google/doclava/parser/Java.g:302:9: ( importDeclaration )*
    549             try { dbg.enterSubRule(3);
    550 
    551             loop3:
    552             do {
    553                 int alt3=2;
    554                 try { dbg.enterDecision(3, decisionCanBacktrack[3]);
    555 
    556                 int LA3_0 = input.LA(1);
    557 
    558                 if ( (LA3_0==IMPORT) ) {
    559                     alt3=1;
    560                 }
    561 
    562 
    563                 } finally {dbg.exitDecision(3);}
    564 
    565                 switch (alt3) {
    566 		case 1 :
    567 		    dbg.enterAlt(1);
    568 
    569 		    // src/com/google/doclava/parser/Java.g:302:10: importDeclaration
    570 		    {
    571 		    dbg.location(302,10);
    572 		    pushFollow(FOLLOW_importDeclaration_in_compilationUnit115);
    573 		    importDeclaration();
    574 
    575 		    state._fsp--;
    576 		    if (state.failed) return ;
    577 
    578 		    }
    579 		    break;
    580 
    581 		default :
    582 		    break loop3;
    583                 }
    584             } while (true);
    585             } finally {dbg.exitSubRule(3);}
    586 
    587             dbg.location(304,9);
    588             // src/com/google/doclava/parser/Java.g:304:9: ( typeDeclaration )*
    589             try { dbg.enterSubRule(4);
    590 
    591             loop4:
    592             do {
    593                 int alt4=2;
    594                 try { dbg.enterDecision(4, decisionCanBacktrack[4]);
    595 
    596                 int LA4_0 = input.LA(1);
    597 
    598                 if ( (LA4_0==IDENTIFIER||LA4_0==ABSTRACT||LA4_0==BOOLEAN||LA4_0==BYTE||(LA4_0>=CHAR && LA4_0<=CLASS)||LA4_0==DOUBLE||LA4_0==ENUM||LA4_0==FINAL||LA4_0==FLOAT||(LA4_0>=INT && LA4_0<=NATIVE)||(LA4_0>=PRIVATE && LA4_0<=PUBLIC)||(LA4_0>=SHORT && LA4_0<=STRICTFP)||LA4_0==SYNCHRONIZED||LA4_0==TRANSIENT||(LA4_0>=VOID && LA4_0<=VOLATILE)||LA4_0==SEMI||LA4_0==MONKEYS_AT||LA4_0==LT) ) {
    599                     alt4=1;
    600                 }
    601 
    602 
    603                 } finally {dbg.exitDecision(4);}
    604 
    605                 switch (alt4) {
    606 		case 1 :
    607 		    dbg.enterAlt(1);
    608 
    609 		    // src/com/google/doclava/parser/Java.g:304:10: typeDeclaration
    610 		    {
    611 		    dbg.location(304,10);
    612 		    pushFollow(FOLLOW_typeDeclaration_in_compilationUnit137);
    613 		    typeDeclaration();
    614 
    615 		    state._fsp--;
    616 		    if (state.failed) return ;
    617 
    618 		    }
    619 		    break;
    620 
    621 		default :
    622 		    break loop4;
    623                 }
    624             } while (true);
    625             } finally {dbg.exitSubRule(4);}
    626 
    627 
    628             }
    629 
    630         }
    631         catch (RecognitionException re) {
    632             reportError(re);
    633             recover(input,re);
    634         }
    635         finally {
    636             if ( state.backtracking>0 ) { memoize(input, 1, compilationUnit_StartIndex); }
    637         }
    638         dbg.location(306, 5);
    639 
    640         }
    641         finally {
    642             dbg.exitRule(getGrammarFileName(), "compilationUnit");
    643             decRuleLevel();
    644             if ( getRuleLevel()==0 ) {dbg.terminate();}
    645         }
    646 
    647         return ;
    648     }
    649     // $ANTLR end "compilationUnit"
    650 
    651 
    652     // $ANTLR start "packageDeclaration"
    653     // src/com/google/doclava/parser/Java.g:308:1: packageDeclaration : 'package' qualifiedName ';' ;
    654     public final void packageDeclaration() throws RecognitionException {
    655         int packageDeclaration_StartIndex = input.index();
    656         try { dbg.enterRule(getGrammarFileName(), "packageDeclaration");
    657         if ( getRuleLevel()==0 ) {dbg.commence();}
    658         incRuleLevel();
    659         dbg.location(308, 1);
    660 
    661         try {
    662             if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return ; }
    663             // src/com/google/doclava/parser/Java.g:309:5: ( 'package' qualifiedName ';' )
    664             dbg.enterAlt(1);
    665 
    666             // src/com/google/doclava/parser/Java.g:309:9: 'package' qualifiedName ';'
    667             {
    668             dbg.location(309,9);
    669             match(input,PACKAGE,FOLLOW_PACKAGE_in_packageDeclaration167); if (state.failed) return ;
    670             dbg.location(309,19);
    671             pushFollow(FOLLOW_qualifiedName_in_packageDeclaration169);
    672             qualifiedName();
    673 
    674             state._fsp--;
    675             if (state.failed) return ;
    676             dbg.location(310,9);
    677             match(input,SEMI,FOLLOW_SEMI_in_packageDeclaration179); if (state.failed) return ;
    678 
    679             }
    680 
    681         }
    682         catch (RecognitionException re) {
    683             reportError(re);
    684             recover(input,re);
    685         }
    686         finally {
    687             if ( state.backtracking>0 ) { memoize(input, 2, packageDeclaration_StartIndex); }
    688         }
    689         dbg.location(311, 5);
    690 
    691         }
    692         finally {
    693             dbg.exitRule(getGrammarFileName(), "packageDeclaration");
    694             decRuleLevel();
    695             if ( getRuleLevel()==0 ) {dbg.terminate();}
    696         }
    697 
    698         return ;
    699     }
    700     // $ANTLR end "packageDeclaration"
    701 
    702 
    703     // $ANTLR start "importDeclaration"
    704     // src/com/google/doclava/parser/Java.g:313:1: importDeclaration : ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' );
    705     public final void importDeclaration() throws RecognitionException {
    706         int importDeclaration_StartIndex = input.index();
    707         try { dbg.enterRule(getGrammarFileName(), "importDeclaration");
    708         if ( getRuleLevel()==0 ) {dbg.commence();}
    709         incRuleLevel();
    710         dbg.location(313, 1);
    711 
    712         try {
    713             if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return ; }
    714             // src/com/google/doclava/parser/Java.g:314:5: ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' )
    715             int alt9=2;
    716             try { dbg.enterDecision(9, decisionCanBacktrack[9]);
    717 
    718             int LA9_0 = input.LA(1);
    719 
    720             if ( (LA9_0==IMPORT) ) {
    721                 int LA9_1 = input.LA(2);
    722 
    723                 if ( (LA9_1==STATIC) ) {
    724                     int LA9_2 = input.LA(3);
    725 
    726                     if ( (LA9_2==IDENTIFIER) ) {
    727                         int LA9_3 = input.LA(4);
    728 
    729                         if ( (LA9_3==DOT) ) {
    730                             int LA9_4 = input.LA(5);
    731 
    732                             if ( (LA9_4==STAR) ) {
    733                                 alt9=1;
    734                             }
    735                             else if ( (LA9_4==IDENTIFIER) ) {
    736                                 alt9=2;
    737                             }
    738                             else {
    739                                 if (state.backtracking>0) {state.failed=true; return ;}
    740                                 NoViableAltException nvae =
    741                                     new NoViableAltException("", 9, 4, input);
    742 
    743                                 dbg.recognitionException(nvae);
    744                                 throw nvae;
    745                             }
    746                         }
    747                         else {
    748                             if (state.backtracking>0) {state.failed=true; return ;}
    749                             NoViableAltException nvae =
    750                                 new NoViableAltException("", 9, 3, input);
    751 
    752                             dbg.recognitionException(nvae);
    753                             throw nvae;
    754                         }
    755                     }
    756                     else {
    757                         if (state.backtracking>0) {state.failed=true; return ;}
    758                         NoViableAltException nvae =
    759                             new NoViableAltException("", 9, 2, input);
    760 
    761                         dbg.recognitionException(nvae);
    762                         throw nvae;
    763                     }
    764                 }
    765                 else if ( (LA9_1==IDENTIFIER) ) {
    766                     int LA9_3 = input.LA(3);
    767 
    768                     if ( (LA9_3==DOT) ) {
    769                         int LA9_4 = input.LA(4);
    770 
    771                         if ( (LA9_4==STAR) ) {
    772                             alt9=1;
    773                         }
    774                         else if ( (LA9_4==IDENTIFIER) ) {
    775                             alt9=2;
    776                         }
    777                         else {
    778                             if (state.backtracking>0) {state.failed=true; return ;}
    779                             NoViableAltException nvae =
    780                                 new NoViableAltException("", 9, 4, input);
    781 
    782                             dbg.recognitionException(nvae);
    783                             throw nvae;
    784                         }
    785                     }
    786                     else {
    787                         if (state.backtracking>0) {state.failed=true; return ;}
    788                         NoViableAltException nvae =
    789                             new NoViableAltException("", 9, 3, input);
    790 
    791                         dbg.recognitionException(nvae);
    792                         throw nvae;
    793                     }
    794                 }
    795                 else {
    796                     if (state.backtracking>0) {state.failed=true; return ;}
    797                     NoViableAltException nvae =
    798                         new NoViableAltException("", 9, 1, input);
    799 
    800                     dbg.recognitionException(nvae);
    801                     throw nvae;
    802                 }
    803             }
    804             else {
    805                 if (state.backtracking>0) {state.failed=true; return ;}
    806                 NoViableAltException nvae =
    807                     new NoViableAltException("", 9, 0, input);
    808 
    809                 dbg.recognitionException(nvae);
    810                 throw nvae;
    811             }
    812             } finally {dbg.exitDecision(9);}
    813 
    814             switch (alt9) {
    815                 case 1 :
    816                     dbg.enterAlt(1);
    817 
    818                     // src/com/google/doclava/parser/Java.g:314:9: 'import' ( 'static' )? IDENTIFIER '.' '*' ';'
    819                     {
    820                     dbg.location(314,9);
    821                     match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration198); if (state.failed) return ;
    822                     dbg.location(315,9);
    823                     // src/com/google/doclava/parser/Java.g:315:9: ( 'static' )?
    824                     int alt5=2;
    825                     try { dbg.enterSubRule(5);
    826                     try { dbg.enterDecision(5, decisionCanBacktrack[5]);
    827 
    828                     int LA5_0 = input.LA(1);
    829 
    830                     if ( (LA5_0==STATIC) ) {
    831                         alt5=1;
    832                     }
    833                     } finally {dbg.exitDecision(5);}
    834 
    835                     switch (alt5) {
    836                         case 1 :
    837                             dbg.enterAlt(1);
    838 
    839                             // src/com/google/doclava/parser/Java.g:315:10: 'static'
    840                             {
    841                             dbg.location(315,10);
    842                             match(input,STATIC,FOLLOW_STATIC_in_importDeclaration209); if (state.failed) return ;
    843 
    844                             }
    845                             break;
    846 
    847                     }
    848                     } finally {dbg.exitSubRule(5);}
    849 
    850                     dbg.location(317,9);
    851                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration230); if (state.failed) return ;
    852                     dbg.location(317,20);
    853                     match(input,DOT,FOLLOW_DOT_in_importDeclaration232); if (state.failed) return ;
    854                     dbg.location(317,24);
    855                     match(input,STAR,FOLLOW_STAR_in_importDeclaration234); if (state.failed) return ;
    856                     dbg.location(318,9);
    857                     match(input,SEMI,FOLLOW_SEMI_in_importDeclaration244); if (state.failed) return ;
    858 
    859                     }
    860                     break;
    861                 case 2 :
    862                     dbg.enterAlt(2);
    863 
    864                     // src/com/google/doclava/parser/Java.g:319:9: 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';'
    865                     {
    866                     dbg.location(319,9);
    867                     match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration254); if (state.failed) return ;
    868                     dbg.location(320,9);
    869                     // src/com/google/doclava/parser/Java.g:320:9: ( 'static' )?
    870                     int alt6=2;
    871                     try { dbg.enterSubRule(6);
    872                     try { dbg.enterDecision(6, decisionCanBacktrack[6]);
    873 
    874                     int LA6_0 = input.LA(1);
    875 
    876                     if ( (LA6_0==STATIC) ) {
    877                         alt6=1;
    878                     }
    879                     } finally {dbg.exitDecision(6);}
    880 
    881                     switch (alt6) {
    882                         case 1 :
    883                             dbg.enterAlt(1);
    884 
    885                             // src/com/google/doclava/parser/Java.g:320:10: 'static'
    886                             {
    887                             dbg.location(320,10);
    888                             match(input,STATIC,FOLLOW_STATIC_in_importDeclaration265); if (state.failed) return ;
    889 
    890                             }
    891                             break;
    892 
    893                     }
    894                     } finally {dbg.exitSubRule(6);}
    895 
    896                     dbg.location(322,9);
    897                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration286); if (state.failed) return ;
    898                     dbg.location(323,9);
    899                     // src/com/google/doclava/parser/Java.g:323:9: ( '.' IDENTIFIER )+
    900                     int cnt7=0;
    901                     try { dbg.enterSubRule(7);
    902 
    903                     loop7:
    904                     do {
    905                         int alt7=2;
    906                         try { dbg.enterDecision(7, decisionCanBacktrack[7]);
    907 
    908                         int LA7_0 = input.LA(1);
    909 
    910                         if ( (LA7_0==DOT) ) {
    911                             int LA7_1 = input.LA(2);
    912 
    913                             if ( (LA7_1==IDENTIFIER) ) {
    914                                 alt7=1;
    915                             }
    916 
    917 
    918                         }
    919 
    920 
    921                         } finally {dbg.exitDecision(7);}
    922 
    923                         switch (alt7) {
    924 			case 1 :
    925 			    dbg.enterAlt(1);
    926 
    927 			    // src/com/google/doclava/parser/Java.g:323:10: '.' IDENTIFIER
    928 			    {
    929 			    dbg.location(323,10);
    930 			    match(input,DOT,FOLLOW_DOT_in_importDeclaration297); if (state.failed) return ;
    931 			    dbg.location(323,14);
    932 			    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration299); if (state.failed) return ;
    933 
    934 			    }
    935 			    break;
    936 
    937 			default :
    938 			    if ( cnt7 >= 1 ) break loop7;
    939 			    if (state.backtracking>0) {state.failed=true; return ;}
    940                                 EarlyExitException eee =
    941                                     new EarlyExitException(7, input);
    942                                 dbg.recognitionException(eee);
    943 
    944                                 throw eee;
    945                         }
    946                         cnt7++;
    947                     } while (true);
    948                     } finally {dbg.exitSubRule(7);}
    949 
    950                     dbg.location(325,9);
    951                     // src/com/google/doclava/parser/Java.g:325:9: ( '.' '*' )?
    952                     int alt8=2;
    953                     try { dbg.enterSubRule(8);
    954                     try { dbg.enterDecision(8, decisionCanBacktrack[8]);
    955 
    956                     int LA8_0 = input.LA(1);
    957 
    958                     if ( (LA8_0==DOT) ) {
    959                         alt8=1;
    960                     }
    961                     } finally {dbg.exitDecision(8);}
    962 
    963                     switch (alt8) {
    964                         case 1 :
    965                             dbg.enterAlt(1);
    966 
    967                             // src/com/google/doclava/parser/Java.g:325:10: '.' '*'
    968                             {
    969                             dbg.location(325,10);
    970                             match(input,DOT,FOLLOW_DOT_in_importDeclaration321); if (state.failed) return ;
    971                             dbg.location(325,14);
    972                             match(input,STAR,FOLLOW_STAR_in_importDeclaration323); if (state.failed) return ;
    973 
    974                             }
    975                             break;
    976 
    977                     }
    978                     } finally {dbg.exitSubRule(8);}
    979 
    980                     dbg.location(327,9);
    981                     match(input,SEMI,FOLLOW_SEMI_in_importDeclaration344); if (state.failed) return ;
    982 
    983                     }
    984                     break;
    985 
    986             }
    987         }
    988         catch (RecognitionException re) {
    989             reportError(re);
    990             recover(input,re);
    991         }
    992         finally {
    993             if ( state.backtracking>0 ) { memoize(input, 3, importDeclaration_StartIndex); }
    994         }
    995         dbg.location(328, 5);
    996 
    997         }
    998         finally {
    999             dbg.exitRule(getGrammarFileName(), "importDeclaration");
   1000             decRuleLevel();
   1001             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1002         }
   1003 
   1004         return ;
   1005     }
   1006     // $ANTLR end "importDeclaration"
   1007 
   1008 
   1009     // $ANTLR start "qualifiedImportName"
   1010     // src/com/google/doclava/parser/Java.g:330:1: qualifiedImportName : IDENTIFIER ( '.' IDENTIFIER )* ;
   1011     public final void qualifiedImportName() throws RecognitionException {
   1012         int qualifiedImportName_StartIndex = input.index();
   1013         try { dbg.enterRule(getGrammarFileName(), "qualifiedImportName");
   1014         if ( getRuleLevel()==0 ) {dbg.commence();}
   1015         incRuleLevel();
   1016         dbg.location(330, 1);
   1017 
   1018         try {
   1019             if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return ; }
   1020             // src/com/google/doclava/parser/Java.g:331:5: ( IDENTIFIER ( '.' IDENTIFIER )* )
   1021             dbg.enterAlt(1);
   1022 
   1023             // src/com/google/doclava/parser/Java.g:331:9: IDENTIFIER ( '.' IDENTIFIER )*
   1024             {
   1025             dbg.location(331,9);
   1026             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName363); if (state.failed) return ;
   1027             dbg.location(332,9);
   1028             // src/com/google/doclava/parser/Java.g:332:9: ( '.' IDENTIFIER )*
   1029             try { dbg.enterSubRule(10);
   1030 
   1031             loop10:
   1032             do {
   1033                 int alt10=2;
   1034                 try { dbg.enterDecision(10, decisionCanBacktrack[10]);
   1035 
   1036                 int LA10_0 = input.LA(1);
   1037 
   1038                 if ( (LA10_0==DOT) ) {
   1039                     alt10=1;
   1040                 }
   1041 
   1042 
   1043                 } finally {dbg.exitDecision(10);}
   1044 
   1045                 switch (alt10) {
   1046 		case 1 :
   1047 		    dbg.enterAlt(1);
   1048 
   1049 		    // src/com/google/doclava/parser/Java.g:332:10: '.' IDENTIFIER
   1050 		    {
   1051 		    dbg.location(332,10);
   1052 		    match(input,DOT,FOLLOW_DOT_in_qualifiedImportName374); if (state.failed) return ;
   1053 		    dbg.location(332,14);
   1054 		    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName376); if (state.failed) return ;
   1055 
   1056 		    }
   1057 		    break;
   1058 
   1059 		default :
   1060 		    break loop10;
   1061                 }
   1062             } while (true);
   1063             } finally {dbg.exitSubRule(10);}
   1064 
   1065 
   1066             }
   1067 
   1068         }
   1069         catch (RecognitionException re) {
   1070             reportError(re);
   1071             recover(input,re);
   1072         }
   1073         finally {
   1074             if ( state.backtracking>0 ) { memoize(input, 4, qualifiedImportName_StartIndex); }
   1075         }
   1076         dbg.location(334, 5);
   1077 
   1078         }
   1079         finally {
   1080             dbg.exitRule(getGrammarFileName(), "qualifiedImportName");
   1081             decRuleLevel();
   1082             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1083         }
   1084 
   1085         return ;
   1086     }
   1087     // $ANTLR end "qualifiedImportName"
   1088 
   1089 
   1090     // $ANTLR start "typeDeclaration"
   1091     // src/com/google/doclava/parser/Java.g:336:1: typeDeclaration : ( classOrInterfaceDeclaration | ';' );
   1092     public final void typeDeclaration() throws RecognitionException {
   1093         int typeDeclaration_StartIndex = input.index();
   1094         try { dbg.enterRule(getGrammarFileName(), "typeDeclaration");
   1095         if ( getRuleLevel()==0 ) {dbg.commence();}
   1096         incRuleLevel();
   1097         dbg.location(336, 1);
   1098 
   1099         try {
   1100             if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return ; }
   1101             // src/com/google/doclava/parser/Java.g:337:5: ( classOrInterfaceDeclaration | ';' )
   1102             int alt11=2;
   1103             try { dbg.enterDecision(11, decisionCanBacktrack[11]);
   1104 
   1105             int LA11_0 = input.LA(1);
   1106 
   1107             if ( (LA11_0==IDENTIFIER||LA11_0==ABSTRACT||LA11_0==BOOLEAN||LA11_0==BYTE||(LA11_0>=CHAR && LA11_0<=CLASS)||LA11_0==DOUBLE||LA11_0==ENUM||LA11_0==FINAL||LA11_0==FLOAT||(LA11_0>=INT && LA11_0<=NATIVE)||(LA11_0>=PRIVATE && LA11_0<=PUBLIC)||(LA11_0>=SHORT && LA11_0<=STRICTFP)||LA11_0==SYNCHRONIZED||LA11_0==TRANSIENT||(LA11_0>=VOID && LA11_0<=VOLATILE)||LA11_0==MONKEYS_AT||LA11_0==LT) ) {
   1108                 alt11=1;
   1109             }
   1110             else if ( (LA11_0==SEMI) ) {
   1111                 alt11=2;
   1112             }
   1113             else {
   1114                 if (state.backtracking>0) {state.failed=true; return ;}
   1115                 NoViableAltException nvae =
   1116                     new NoViableAltException("", 11, 0, input);
   1117 
   1118                 dbg.recognitionException(nvae);
   1119                 throw nvae;
   1120             }
   1121             } finally {dbg.exitDecision(11);}
   1122 
   1123             switch (alt11) {
   1124                 case 1 :
   1125                     dbg.enterAlt(1);
   1126 
   1127                     // src/com/google/doclava/parser/Java.g:337:9: classOrInterfaceDeclaration
   1128                     {
   1129                     dbg.location(337,9);
   1130                     pushFollow(FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration406);
   1131                     classOrInterfaceDeclaration();
   1132 
   1133                     state._fsp--;
   1134                     if (state.failed) return ;
   1135 
   1136                     }
   1137                     break;
   1138                 case 2 :
   1139                     dbg.enterAlt(2);
   1140 
   1141                     // src/com/google/doclava/parser/Java.g:338:9: ';'
   1142                     {
   1143                     dbg.location(338,9);
   1144                     match(input,SEMI,FOLLOW_SEMI_in_typeDeclaration416); if (state.failed) return ;
   1145 
   1146                     }
   1147                     break;
   1148 
   1149             }
   1150         }
   1151         catch (RecognitionException re) {
   1152             reportError(re);
   1153             recover(input,re);
   1154         }
   1155         finally {
   1156             if ( state.backtracking>0 ) { memoize(input, 5, typeDeclaration_StartIndex); }
   1157         }
   1158         dbg.location(339, 5);
   1159 
   1160         }
   1161         finally {
   1162             dbg.exitRule(getGrammarFileName(), "typeDeclaration");
   1163             decRuleLevel();
   1164             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1165         }
   1166 
   1167         return ;
   1168     }
   1169     // $ANTLR end "typeDeclaration"
   1170 
   1171 
   1172     // $ANTLR start "classOrInterfaceDeclaration"
   1173     // src/com/google/doclava/parser/Java.g:341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );
   1174     public final void classOrInterfaceDeclaration() throws RecognitionException {
   1175         int classOrInterfaceDeclaration_StartIndex = input.index();
   1176         try { dbg.enterRule(getGrammarFileName(), "classOrInterfaceDeclaration");
   1177         if ( getRuleLevel()==0 ) {dbg.commence();}
   1178         incRuleLevel();
   1179         dbg.location(341, 1);
   1180 
   1181         try {
   1182             if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return ; }
   1183             // src/com/google/doclava/parser/Java.g:342:5: ( classDeclaration | interfaceDeclaration )
   1184             int alt12=2;
   1185             try { dbg.enterDecision(12, decisionCanBacktrack[12]);
   1186 
   1187             try {
   1188                 isCyclicDecision = true;
   1189                 alt12 = dfa12.predict(input);
   1190             }
   1191             catch (NoViableAltException nvae) {
   1192                 dbg.recognitionException(nvae);
   1193                 throw nvae;
   1194             }
   1195             } finally {dbg.exitDecision(12);}
   1196 
   1197             switch (alt12) {
   1198                 case 1 :
   1199                     dbg.enterAlt(1);
   1200 
   1201                     // src/com/google/doclava/parser/Java.g:342:10: classDeclaration
   1202                     {
   1203                     dbg.location(342,10);
   1204                     pushFollow(FOLLOW_classDeclaration_in_classOrInterfaceDeclaration436);
   1205                     classDeclaration();
   1206 
   1207                     state._fsp--;
   1208                     if (state.failed) return ;
   1209 
   1210                     }
   1211                     break;
   1212                 case 2 :
   1213                     dbg.enterAlt(2);
   1214 
   1215                     // src/com/google/doclava/parser/Java.g:343:9: interfaceDeclaration
   1216                     {
   1217                     dbg.location(343,9);
   1218                     pushFollow(FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration446);
   1219                     interfaceDeclaration();
   1220 
   1221                     state._fsp--;
   1222                     if (state.failed) return ;
   1223 
   1224                     }
   1225                     break;
   1226 
   1227             }
   1228         }
   1229         catch (RecognitionException re) {
   1230             reportError(re);
   1231             recover(input,re);
   1232         }
   1233         finally {
   1234             if ( state.backtracking>0 ) { memoize(input, 6, classOrInterfaceDeclaration_StartIndex); }
   1235         }
   1236         dbg.location(344, 5);
   1237 
   1238         }
   1239         finally {
   1240             dbg.exitRule(getGrammarFileName(), "classOrInterfaceDeclaration");
   1241             decRuleLevel();
   1242             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1243         }
   1244 
   1245         return ;
   1246     }
   1247     // $ANTLR end "classOrInterfaceDeclaration"
   1248 
   1249 
   1250     // $ANTLR start "modifiers"
   1251     // src/com/google/doclava/parser/Java.g:347:1: modifiers : ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* ;
   1252     public final void modifiers() throws RecognitionException {
   1253         int modifiers_StartIndex = input.index();
   1254         try { dbg.enterRule(getGrammarFileName(), "modifiers");
   1255         if ( getRuleLevel()==0 ) {dbg.commence();}
   1256         incRuleLevel();
   1257         dbg.location(347, 1);
   1258 
   1259         try {
   1260             if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return ; }
   1261             // src/com/google/doclava/parser/Java.g:348:5: ( ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* )
   1262             dbg.enterAlt(1);
   1263 
   1264             // src/com/google/doclava/parser/Java.g:349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*
   1265             {
   1266             dbg.location(349,5);
   1267             // src/com/google/doclava/parser/Java.g:349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*
   1268             try { dbg.enterSubRule(13);
   1269 
   1270             loop13:
   1271             do {
   1272                 int alt13=13;
   1273                 try { dbg.enterDecision(13, decisionCanBacktrack[13]);
   1274 
   1275                 try {
   1276                     isCyclicDecision = true;
   1277                     alt13 = dfa13.predict(input);
   1278                 }
   1279                 catch (NoViableAltException nvae) {
   1280                     dbg.recognitionException(nvae);
   1281                     throw nvae;
   1282                 }
   1283                 } finally {dbg.exitDecision(13);}
   1284 
   1285                 switch (alt13) {
   1286 		case 1 :
   1287 		    dbg.enterAlt(1);
   1288 
   1289 		    // src/com/google/doclava/parser/Java.g:349:10: annotation
   1290 		    {
   1291 		    dbg.location(349,10);
   1292 		    pushFollow(FOLLOW_annotation_in_modifiers473);
   1293 		    annotation();
   1294 
   1295 		    state._fsp--;
   1296 		    if (state.failed) return ;
   1297 
   1298 		    }
   1299 		    break;
   1300 		case 2 :
   1301 		    dbg.enterAlt(2);
   1302 
   1303 		    // src/com/google/doclava/parser/Java.g:350:9: 'public'
   1304 		    {
   1305 		    dbg.location(350,9);
   1306 		    match(input,PUBLIC,FOLLOW_PUBLIC_in_modifiers483); if (state.failed) return ;
   1307 
   1308 		    }
   1309 		    break;
   1310 		case 3 :
   1311 		    dbg.enterAlt(3);
   1312 
   1313 		    // src/com/google/doclava/parser/Java.g:351:9: 'protected'
   1314 		    {
   1315 		    dbg.location(351,9);
   1316 		    match(input,PROTECTED,FOLLOW_PROTECTED_in_modifiers493); if (state.failed) return ;
   1317 
   1318 		    }
   1319 		    break;
   1320 		case 4 :
   1321 		    dbg.enterAlt(4);
   1322 
   1323 		    // src/com/google/doclava/parser/Java.g:352:9: 'private'
   1324 		    {
   1325 		    dbg.location(352,9);
   1326 		    match(input,PRIVATE,FOLLOW_PRIVATE_in_modifiers503); if (state.failed) return ;
   1327 
   1328 		    }
   1329 		    break;
   1330 		case 5 :
   1331 		    dbg.enterAlt(5);
   1332 
   1333 		    // src/com/google/doclava/parser/Java.g:353:9: 'static'
   1334 		    {
   1335 		    dbg.location(353,9);
   1336 		    match(input,STATIC,FOLLOW_STATIC_in_modifiers513); if (state.failed) return ;
   1337 
   1338 		    }
   1339 		    break;
   1340 		case 6 :
   1341 		    dbg.enterAlt(6);
   1342 
   1343 		    // src/com/google/doclava/parser/Java.g:354:9: 'abstract'
   1344 		    {
   1345 		    dbg.location(354,9);
   1346 		    match(input,ABSTRACT,FOLLOW_ABSTRACT_in_modifiers523); if (state.failed) return ;
   1347 
   1348 		    }
   1349 		    break;
   1350 		case 7 :
   1351 		    dbg.enterAlt(7);
   1352 
   1353 		    // src/com/google/doclava/parser/Java.g:355:9: 'final'
   1354 		    {
   1355 		    dbg.location(355,9);
   1356 		    match(input,FINAL,FOLLOW_FINAL_in_modifiers533); if (state.failed) return ;
   1357 
   1358 		    }
   1359 		    break;
   1360 		case 8 :
   1361 		    dbg.enterAlt(8);
   1362 
   1363 		    // src/com/google/doclava/parser/Java.g:356:9: 'native'
   1364 		    {
   1365 		    dbg.location(356,9);
   1366 		    match(input,NATIVE,FOLLOW_NATIVE_in_modifiers543); if (state.failed) return ;
   1367 
   1368 		    }
   1369 		    break;
   1370 		case 9 :
   1371 		    dbg.enterAlt(9);
   1372 
   1373 		    // src/com/google/doclava/parser/Java.g:357:9: 'synchronized'
   1374 		    {
   1375 		    dbg.location(357,9);
   1376 		    match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_modifiers553); if (state.failed) return ;
   1377 
   1378 		    }
   1379 		    break;
   1380 		case 10 :
   1381 		    dbg.enterAlt(10);
   1382 
   1383 		    // src/com/google/doclava/parser/Java.g:358:9: 'transient'
   1384 		    {
   1385 		    dbg.location(358,9);
   1386 		    match(input,TRANSIENT,FOLLOW_TRANSIENT_in_modifiers563); if (state.failed) return ;
   1387 
   1388 		    }
   1389 		    break;
   1390 		case 11 :
   1391 		    dbg.enterAlt(11);
   1392 
   1393 		    // src/com/google/doclava/parser/Java.g:359:9: 'volatile'
   1394 		    {
   1395 		    dbg.location(359,9);
   1396 		    match(input,VOLATILE,FOLLOW_VOLATILE_in_modifiers573); if (state.failed) return ;
   1397 
   1398 		    }
   1399 		    break;
   1400 		case 12 :
   1401 		    dbg.enterAlt(12);
   1402 
   1403 		    // src/com/google/doclava/parser/Java.g:360:9: 'strictfp'
   1404 		    {
   1405 		    dbg.location(360,9);
   1406 		    match(input,STRICTFP,FOLLOW_STRICTFP_in_modifiers583); if (state.failed) return ;
   1407 
   1408 		    }
   1409 		    break;
   1410 
   1411 		default :
   1412 		    break loop13;
   1413                 }
   1414             } while (true);
   1415             } finally {dbg.exitSubRule(13);}
   1416 
   1417 
   1418             }
   1419 
   1420         }
   1421         catch (RecognitionException re) {
   1422             reportError(re);
   1423             recover(input,re);
   1424         }
   1425         finally {
   1426             if ( state.backtracking>0 ) { memoize(input, 7, modifiers_StartIndex); }
   1427         }
   1428         dbg.location(362, 5);
   1429 
   1430         }
   1431         finally {
   1432             dbg.exitRule(getGrammarFileName(), "modifiers");
   1433             decRuleLevel();
   1434             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1435         }
   1436 
   1437         return ;
   1438     }
   1439     // $ANTLR end "modifiers"
   1440 
   1441 
   1442     // $ANTLR start "variableModifiers"
   1443     // src/com/google/doclava/parser/Java.g:365:1: variableModifiers : ( 'final' | annotation )* ;
   1444     public final void variableModifiers() throws RecognitionException {
   1445         int variableModifiers_StartIndex = input.index();
   1446         try { dbg.enterRule(getGrammarFileName(), "variableModifiers");
   1447         if ( getRuleLevel()==0 ) {dbg.commence();}
   1448         incRuleLevel();
   1449         dbg.location(365, 1);
   1450 
   1451         try {
   1452             if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return ; }
   1453             // src/com/google/doclava/parser/Java.g:366:5: ( ( 'final' | annotation )* )
   1454             dbg.enterAlt(1);
   1455 
   1456             // src/com/google/doclava/parser/Java.g:366:9: ( 'final' | annotation )*
   1457             {
   1458             dbg.location(366,9);
   1459             // src/com/google/doclava/parser/Java.g:366:9: ( 'final' | annotation )*
   1460             try { dbg.enterSubRule(14);
   1461 
   1462             loop14:
   1463             do {
   1464                 int alt14=3;
   1465                 try { dbg.enterDecision(14, decisionCanBacktrack[14]);
   1466 
   1467                 int LA14_0 = input.LA(1);
   1468 
   1469                 if ( (LA14_0==FINAL) ) {
   1470                     alt14=1;
   1471                 }
   1472                 else if ( (LA14_0==MONKEYS_AT) ) {
   1473                     alt14=2;
   1474                 }
   1475 
   1476 
   1477                 } finally {dbg.exitDecision(14);}
   1478 
   1479                 switch (alt14) {
   1480 		case 1 :
   1481 		    dbg.enterAlt(1);
   1482 
   1483 		    // src/com/google/doclava/parser/Java.g:366:13: 'final'
   1484 		    {
   1485 		    dbg.location(366,13);
   1486 		    match(input,FINAL,FOLLOW_FINAL_in_variableModifiers614); if (state.failed) return ;
   1487 
   1488 		    }
   1489 		    break;
   1490 		case 2 :
   1491 		    dbg.enterAlt(2);
   1492 
   1493 		    // src/com/google/doclava/parser/Java.g:367:13: annotation
   1494 		    {
   1495 		    dbg.location(367,13);
   1496 		    pushFollow(FOLLOW_annotation_in_variableModifiers628);
   1497 		    annotation();
   1498 
   1499 		    state._fsp--;
   1500 		    if (state.failed) return ;
   1501 
   1502 		    }
   1503 		    break;
   1504 
   1505 		default :
   1506 		    break loop14;
   1507                 }
   1508             } while (true);
   1509             } finally {dbg.exitSubRule(14);}
   1510 
   1511 
   1512             }
   1513 
   1514         }
   1515         catch (RecognitionException re) {
   1516             reportError(re);
   1517             recover(input,re);
   1518         }
   1519         finally {
   1520             if ( state.backtracking>0 ) { memoize(input, 8, variableModifiers_StartIndex); }
   1521         }
   1522         dbg.location(369, 5);
   1523 
   1524         }
   1525         finally {
   1526             dbg.exitRule(getGrammarFileName(), "variableModifiers");
   1527             decRuleLevel();
   1528             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1529         }
   1530 
   1531         return ;
   1532     }
   1533     // $ANTLR end "variableModifiers"
   1534 
   1535 
   1536     // $ANTLR start "classDeclaration"
   1537     // src/com/google/doclava/parser/Java.g:372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );
   1538     public final void classDeclaration() throws RecognitionException {
   1539         int classDeclaration_StartIndex = input.index();
   1540         try { dbg.enterRule(getGrammarFileName(), "classDeclaration");
   1541         if ( getRuleLevel()==0 ) {dbg.commence();}
   1542         incRuleLevel();
   1543         dbg.location(372, 1);
   1544 
   1545         try {
   1546             if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return ; }
   1547             // src/com/google/doclava/parser/Java.g:373:5: ( normalClassDeclaration | enumDeclaration )
   1548             int alt15=2;
   1549             try { dbg.enterDecision(15, decisionCanBacktrack[15]);
   1550 
   1551             try {
   1552                 isCyclicDecision = true;
   1553                 alt15 = dfa15.predict(input);
   1554             }
   1555             catch (NoViableAltException nvae) {
   1556                 dbg.recognitionException(nvae);
   1557                 throw nvae;
   1558             }
   1559             } finally {dbg.exitDecision(15);}
   1560 
   1561             switch (alt15) {
   1562                 case 1 :
   1563                     dbg.enterAlt(1);
   1564 
   1565                     // src/com/google/doclava/parser/Java.g:373:9: normalClassDeclaration
   1566                     {
   1567                     dbg.location(373,9);
   1568                     pushFollow(FOLLOW_normalClassDeclaration_in_classDeclaration659);
   1569                     normalClassDeclaration();
   1570 
   1571                     state._fsp--;
   1572                     if (state.failed) return ;
   1573 
   1574                     }
   1575                     break;
   1576                 case 2 :
   1577                     dbg.enterAlt(2);
   1578 
   1579                     // src/com/google/doclava/parser/Java.g:374:9: enumDeclaration
   1580                     {
   1581                     dbg.location(374,9);
   1582                     pushFollow(FOLLOW_enumDeclaration_in_classDeclaration669);
   1583                     enumDeclaration();
   1584 
   1585                     state._fsp--;
   1586                     if (state.failed) return ;
   1587 
   1588                     }
   1589                     break;
   1590 
   1591             }
   1592         }
   1593         catch (RecognitionException re) {
   1594             reportError(re);
   1595             recover(input,re);
   1596         }
   1597         finally {
   1598             if ( state.backtracking>0 ) { memoize(input, 9, classDeclaration_StartIndex); }
   1599         }
   1600         dbg.location(375, 5);
   1601 
   1602         }
   1603         finally {
   1604             dbg.exitRule(getGrammarFileName(), "classDeclaration");
   1605             decRuleLevel();
   1606             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1607         }
   1608 
   1609         return ;
   1610     }
   1611     // $ANTLR end "classDeclaration"
   1612 
   1613 
   1614     // $ANTLR start "normalClassDeclaration"
   1615     // src/com/google/doclava/parser/Java.g:377:1: normalClassDeclaration : modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody ;
   1616     public final void normalClassDeclaration() throws RecognitionException {
   1617         int normalClassDeclaration_StartIndex = input.index();
   1618         try { dbg.enterRule(getGrammarFileName(), "normalClassDeclaration");
   1619         if ( getRuleLevel()==0 ) {dbg.commence();}
   1620         incRuleLevel();
   1621         dbg.location(377, 1);
   1622 
   1623         try {
   1624             if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return ; }
   1625             // src/com/google/doclava/parser/Java.g:378:5: ( modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody )
   1626             dbg.enterAlt(1);
   1627 
   1628             // src/com/google/doclava/parser/Java.g:378:9: modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody
   1629             {
   1630             dbg.location(378,9);
   1631             pushFollow(FOLLOW_modifiers_in_normalClassDeclaration688);
   1632             modifiers();
   1633 
   1634             state._fsp--;
   1635             if (state.failed) return ;
   1636             dbg.location(378,20);
   1637             match(input,CLASS,FOLLOW_CLASS_in_normalClassDeclaration691); if (state.failed) return ;
   1638             dbg.location(378,28);
   1639             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalClassDeclaration693); if (state.failed) return ;
   1640             dbg.location(379,9);
   1641             // src/com/google/doclava/parser/Java.g:379:9: ( typeParameters )?
   1642             int alt16=2;
   1643             try { dbg.enterSubRule(16);
   1644             try { dbg.enterDecision(16, decisionCanBacktrack[16]);
   1645 
   1646             int LA16_0 = input.LA(1);
   1647 
   1648             if ( (LA16_0==LT) ) {
   1649                 alt16=1;
   1650             }
   1651             } finally {dbg.exitDecision(16);}
   1652 
   1653             switch (alt16) {
   1654                 case 1 :
   1655                     dbg.enterAlt(1);
   1656 
   1657                     // src/com/google/doclava/parser/Java.g:379:10: typeParameters
   1658                     {
   1659                     dbg.location(379,10);
   1660                     pushFollow(FOLLOW_typeParameters_in_normalClassDeclaration704);
   1661                     typeParameters();
   1662 
   1663                     state._fsp--;
   1664                     if (state.failed) return ;
   1665 
   1666                     }
   1667                     break;
   1668 
   1669             }
   1670             } finally {dbg.exitSubRule(16);}
   1671 
   1672             dbg.location(381,9);
   1673             // src/com/google/doclava/parser/Java.g:381:9: ( 'extends' type )?
   1674             int alt17=2;
   1675             try { dbg.enterSubRule(17);
   1676             try { dbg.enterDecision(17, decisionCanBacktrack[17]);
   1677 
   1678             int LA17_0 = input.LA(1);
   1679 
   1680             if ( (LA17_0==EXTENDS) ) {
   1681                 alt17=1;
   1682             }
   1683             } finally {dbg.exitDecision(17);}
   1684 
   1685             switch (alt17) {
   1686                 case 1 :
   1687                     dbg.enterAlt(1);
   1688 
   1689                     // src/com/google/doclava/parser/Java.g:381:10: 'extends' type
   1690                     {
   1691                     dbg.location(381,10);
   1692                     match(input,EXTENDS,FOLLOW_EXTENDS_in_normalClassDeclaration726); if (state.failed) return ;
   1693                     dbg.location(381,20);
   1694                     pushFollow(FOLLOW_type_in_normalClassDeclaration728);
   1695                     type();
   1696 
   1697                     state._fsp--;
   1698                     if (state.failed) return ;
   1699 
   1700                     }
   1701                     break;
   1702 
   1703             }
   1704             } finally {dbg.exitSubRule(17);}
   1705 
   1706             dbg.location(383,9);
   1707             // src/com/google/doclava/parser/Java.g:383:9: ( 'implements' typeList )?
   1708             int alt18=2;
   1709             try { dbg.enterSubRule(18);
   1710             try { dbg.enterDecision(18, decisionCanBacktrack[18]);
   1711 
   1712             int LA18_0 = input.LA(1);
   1713 
   1714             if ( (LA18_0==IMPLEMENTS) ) {
   1715                 alt18=1;
   1716             }
   1717             } finally {dbg.exitDecision(18);}
   1718 
   1719             switch (alt18) {
   1720                 case 1 :
   1721                     dbg.enterAlt(1);
   1722 
   1723                     // src/com/google/doclava/parser/Java.g:383:10: 'implements' typeList
   1724                     {
   1725                     dbg.location(383,10);
   1726                     match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_normalClassDeclaration750); if (state.failed) return ;
   1727                     dbg.location(383,23);
   1728                     pushFollow(FOLLOW_typeList_in_normalClassDeclaration752);
   1729                     typeList();
   1730 
   1731                     state._fsp--;
   1732                     if (state.failed) return ;
   1733 
   1734                     }
   1735                     break;
   1736 
   1737             }
   1738             } finally {dbg.exitSubRule(18);}
   1739 
   1740             dbg.location(385,9);
   1741             pushFollow(FOLLOW_classBody_in_normalClassDeclaration773);
   1742             classBody();
   1743 
   1744             state._fsp--;
   1745             if (state.failed) return ;
   1746 
   1747             }
   1748 
   1749         }
   1750         catch (RecognitionException re) {
   1751             reportError(re);
   1752             recover(input,re);
   1753         }
   1754         finally {
   1755             if ( state.backtracking>0 ) { memoize(input, 10, normalClassDeclaration_StartIndex); }
   1756         }
   1757         dbg.location(386, 5);
   1758 
   1759         }
   1760         finally {
   1761             dbg.exitRule(getGrammarFileName(), "normalClassDeclaration");
   1762             decRuleLevel();
   1763             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1764         }
   1765 
   1766         return ;
   1767     }
   1768     // $ANTLR end "normalClassDeclaration"
   1769 
   1770 
   1771     // $ANTLR start "typeParameters"
   1772     // src/com/google/doclava/parser/Java.g:389:1: typeParameters : '<' typeParameter ( ',' typeParameter )* '>' ;
   1773     public final void typeParameters() throws RecognitionException {
   1774         int typeParameters_StartIndex = input.index();
   1775         try { dbg.enterRule(getGrammarFileName(), "typeParameters");
   1776         if ( getRuleLevel()==0 ) {dbg.commence();}
   1777         incRuleLevel();
   1778         dbg.location(389, 1);
   1779 
   1780         try {
   1781             if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return ; }
   1782             // src/com/google/doclava/parser/Java.g:390:5: ( '<' typeParameter ( ',' typeParameter )* '>' )
   1783             dbg.enterAlt(1);
   1784 
   1785             // src/com/google/doclava/parser/Java.g:390:9: '<' typeParameter ( ',' typeParameter )* '>'
   1786             {
   1787             dbg.location(390,9);
   1788             match(input,LT,FOLLOW_LT_in_typeParameters793); if (state.failed) return ;
   1789             dbg.location(391,13);
   1790             pushFollow(FOLLOW_typeParameter_in_typeParameters807);
   1791             typeParameter();
   1792 
   1793             state._fsp--;
   1794             if (state.failed) return ;
   1795             dbg.location(392,13);
   1796             // src/com/google/doclava/parser/Java.g:392:13: ( ',' typeParameter )*
   1797             try { dbg.enterSubRule(19);
   1798 
   1799             loop19:
   1800             do {
   1801                 int alt19=2;
   1802                 try { dbg.enterDecision(19, decisionCanBacktrack[19]);
   1803 
   1804                 int LA19_0 = input.LA(1);
   1805 
   1806                 if ( (LA19_0==COMMA) ) {
   1807                     alt19=1;
   1808                 }
   1809 
   1810 
   1811                 } finally {dbg.exitDecision(19);}
   1812 
   1813                 switch (alt19) {
   1814 		case 1 :
   1815 		    dbg.enterAlt(1);
   1816 
   1817 		    // src/com/google/doclava/parser/Java.g:392:14: ',' typeParameter
   1818 		    {
   1819 		    dbg.location(392,14);
   1820 		    match(input,COMMA,FOLLOW_COMMA_in_typeParameters822); if (state.failed) return ;
   1821 		    dbg.location(392,18);
   1822 		    pushFollow(FOLLOW_typeParameter_in_typeParameters824);
   1823 		    typeParameter();
   1824 
   1825 		    state._fsp--;
   1826 		    if (state.failed) return ;
   1827 
   1828 		    }
   1829 		    break;
   1830 
   1831 		default :
   1832 		    break loop19;
   1833                 }
   1834             } while (true);
   1835             } finally {dbg.exitSubRule(19);}
   1836 
   1837             dbg.location(394,9);
   1838             match(input,GT,FOLLOW_GT_in_typeParameters849); if (state.failed) return ;
   1839 
   1840             }
   1841 
   1842         }
   1843         catch (RecognitionException re) {
   1844             reportError(re);
   1845             recover(input,re);
   1846         }
   1847         finally {
   1848             if ( state.backtracking>0 ) { memoize(input, 11, typeParameters_StartIndex); }
   1849         }
   1850         dbg.location(395, 5);
   1851 
   1852         }
   1853         finally {
   1854             dbg.exitRule(getGrammarFileName(), "typeParameters");
   1855             decRuleLevel();
   1856             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1857         }
   1858 
   1859         return ;
   1860     }
   1861     // $ANTLR end "typeParameters"
   1862 
   1863 
   1864     // $ANTLR start "typeParameter"
   1865     // src/com/google/doclava/parser/Java.g:397:1: typeParameter : IDENTIFIER ( 'extends' typeBound )? ;
   1866     public final void typeParameter() throws RecognitionException {
   1867         int typeParameter_StartIndex = input.index();
   1868         try { dbg.enterRule(getGrammarFileName(), "typeParameter");
   1869         if ( getRuleLevel()==0 ) {dbg.commence();}
   1870         incRuleLevel();
   1871         dbg.location(397, 1);
   1872 
   1873         try {
   1874             if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return ; }
   1875             // src/com/google/doclava/parser/Java.g:398:5: ( IDENTIFIER ( 'extends' typeBound )? )
   1876             dbg.enterAlt(1);
   1877 
   1878             // src/com/google/doclava/parser/Java.g:398:9: IDENTIFIER ( 'extends' typeBound )?
   1879             {
   1880             dbg.location(398,9);
   1881             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeParameter868); if (state.failed) return ;
   1882             dbg.location(399,9);
   1883             // src/com/google/doclava/parser/Java.g:399:9: ( 'extends' typeBound )?
   1884             int alt20=2;
   1885             try { dbg.enterSubRule(20);
   1886             try { dbg.enterDecision(20, decisionCanBacktrack[20]);
   1887 
   1888             int LA20_0 = input.LA(1);
   1889 
   1890             if ( (LA20_0==EXTENDS) ) {
   1891                 alt20=1;
   1892             }
   1893             } finally {dbg.exitDecision(20);}
   1894 
   1895             switch (alt20) {
   1896                 case 1 :
   1897                     dbg.enterAlt(1);
   1898 
   1899                     // src/com/google/doclava/parser/Java.g:399:10: 'extends' typeBound
   1900                     {
   1901                     dbg.location(399,10);
   1902                     match(input,EXTENDS,FOLLOW_EXTENDS_in_typeParameter879); if (state.failed) return ;
   1903                     dbg.location(399,20);
   1904                     pushFollow(FOLLOW_typeBound_in_typeParameter881);
   1905                     typeBound();
   1906 
   1907                     state._fsp--;
   1908                     if (state.failed) return ;
   1909 
   1910                     }
   1911                     break;
   1912 
   1913             }
   1914             } finally {dbg.exitSubRule(20);}
   1915 
   1916 
   1917             }
   1918 
   1919         }
   1920         catch (RecognitionException re) {
   1921             reportError(re);
   1922             recover(input,re);
   1923         }
   1924         finally {
   1925             if ( state.backtracking>0 ) { memoize(input, 12, typeParameter_StartIndex); }
   1926         }
   1927         dbg.location(401, 5);
   1928 
   1929         }
   1930         finally {
   1931             dbg.exitRule(getGrammarFileName(), "typeParameter");
   1932             decRuleLevel();
   1933             if ( getRuleLevel()==0 ) {dbg.terminate();}
   1934         }
   1935 
   1936         return ;
   1937     }
   1938     // $ANTLR end "typeParameter"
   1939 
   1940 
   1941     // $ANTLR start "typeBound"
   1942     // src/com/google/doclava/parser/Java.g:404:1: typeBound : type ( '&' type )* ;
   1943     public final void typeBound() throws RecognitionException {
   1944         int typeBound_StartIndex = input.index();
   1945         try { dbg.enterRule(getGrammarFileName(), "typeBound");
   1946         if ( getRuleLevel()==0 ) {dbg.commence();}
   1947         incRuleLevel();
   1948         dbg.location(404, 1);
   1949 
   1950         try {
   1951             if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return ; }
   1952             // src/com/google/doclava/parser/Java.g:405:5: ( type ( '&' type )* )
   1953             dbg.enterAlt(1);
   1954 
   1955             // src/com/google/doclava/parser/Java.g:405:9: type ( '&' type )*
   1956             {
   1957             dbg.location(405,9);
   1958             pushFollow(FOLLOW_type_in_typeBound912);
   1959             type();
   1960 
   1961             state._fsp--;
   1962             if (state.failed) return ;
   1963             dbg.location(406,9);
   1964             // src/com/google/doclava/parser/Java.g:406:9: ( '&' type )*
   1965             try { dbg.enterSubRule(21);
   1966 
   1967             loop21:
   1968             do {
   1969                 int alt21=2;
   1970                 try { dbg.enterDecision(21, decisionCanBacktrack[21]);
   1971 
   1972                 int LA21_0 = input.LA(1);
   1973 
   1974                 if ( (LA21_0==AMP) ) {
   1975                     alt21=1;
   1976                 }
   1977 
   1978 
   1979                 } finally {dbg.exitDecision(21);}
   1980 
   1981                 switch (alt21) {
   1982 		case 1 :
   1983 		    dbg.enterAlt(1);
   1984 
   1985 		    // src/com/google/doclava/parser/Java.g:406:10: '&' type
   1986 		    {
   1987 		    dbg.location(406,10);
   1988 		    match(input,AMP,FOLLOW_AMP_in_typeBound923); if (state.failed) return ;
   1989 		    dbg.location(406,14);
   1990 		    pushFollow(FOLLOW_type_in_typeBound925);
   1991 		    type();
   1992 
   1993 		    state._fsp--;
   1994 		    if (state.failed) return ;
   1995 
   1996 		    }
   1997 		    break;
   1998 
   1999 		default :
   2000 		    break loop21;
   2001                 }
   2002             } while (true);
   2003             } finally {dbg.exitSubRule(21);}
   2004 
   2005 
   2006             }
   2007 
   2008         }
   2009         catch (RecognitionException re) {
   2010             reportError(re);
   2011             recover(input,re);
   2012         }
   2013         finally {
   2014             if ( state.backtracking>0 ) { memoize(input, 13, typeBound_StartIndex); }
   2015         }
   2016         dbg.location(408, 5);
   2017 
   2018         }
   2019         finally {
   2020             dbg.exitRule(getGrammarFileName(), "typeBound");
   2021             decRuleLevel();
   2022             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2023         }
   2024 
   2025         return ;
   2026     }
   2027     // $ANTLR end "typeBound"
   2028 
   2029 
   2030     // $ANTLR start "enumDeclaration"
   2031     // src/com/google/doclava/parser/Java.g:411:1: enumDeclaration : modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody ;
   2032     public final void enumDeclaration() throws RecognitionException {
   2033         int enumDeclaration_StartIndex = input.index();
   2034         try { dbg.enterRule(getGrammarFileName(), "enumDeclaration");
   2035         if ( getRuleLevel()==0 ) {dbg.commence();}
   2036         incRuleLevel();
   2037         dbg.location(411, 1);
   2038 
   2039         try {
   2040             if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return ; }
   2041             // src/com/google/doclava/parser/Java.g:412:5: ( modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody )
   2042             dbg.enterAlt(1);
   2043 
   2044             // src/com/google/doclava/parser/Java.g:412:9: modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody
   2045             {
   2046             dbg.location(412,9);
   2047             pushFollow(FOLLOW_modifiers_in_enumDeclaration956);
   2048             modifiers();
   2049 
   2050             state._fsp--;
   2051             if (state.failed) return ;
   2052             dbg.location(413,9);
   2053             // src/com/google/doclava/parser/Java.g:413:9: ( 'enum' )
   2054             dbg.enterAlt(1);
   2055 
   2056             // src/com/google/doclava/parser/Java.g:413:10: 'enum'
   2057             {
   2058             dbg.location(413,10);
   2059             match(input,ENUM,FOLLOW_ENUM_in_enumDeclaration967); if (state.failed) return ;
   2060 
   2061             }
   2062 
   2063             dbg.location(415,9);
   2064             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumDeclaration987); if (state.failed) return ;
   2065             dbg.location(416,9);
   2066             // src/com/google/doclava/parser/Java.g:416:9: ( 'implements' typeList )?
   2067             int alt22=2;
   2068             try { dbg.enterSubRule(22);
   2069             try { dbg.enterDecision(22, decisionCanBacktrack[22]);
   2070 
   2071             int LA22_0 = input.LA(1);
   2072 
   2073             if ( (LA22_0==IMPLEMENTS) ) {
   2074                 alt22=1;
   2075             }
   2076             } finally {dbg.exitDecision(22);}
   2077 
   2078             switch (alt22) {
   2079                 case 1 :
   2080                     dbg.enterAlt(1);
   2081 
   2082                     // src/com/google/doclava/parser/Java.g:416:10: 'implements' typeList
   2083                     {
   2084                     dbg.location(416,10);
   2085                     match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_enumDeclaration998); if (state.failed) return ;
   2086                     dbg.location(416,23);
   2087                     pushFollow(FOLLOW_typeList_in_enumDeclaration1000);
   2088                     typeList();
   2089 
   2090                     state._fsp--;
   2091                     if (state.failed) return ;
   2092 
   2093                     }
   2094                     break;
   2095 
   2096             }
   2097             } finally {dbg.exitSubRule(22);}
   2098 
   2099             dbg.location(418,9);
   2100             pushFollow(FOLLOW_enumBody_in_enumDeclaration1021);
   2101             enumBody();
   2102 
   2103             state._fsp--;
   2104             if (state.failed) return ;
   2105 
   2106             }
   2107 
   2108         }
   2109         catch (RecognitionException re) {
   2110             reportError(re);
   2111             recover(input,re);
   2112         }
   2113         finally {
   2114             if ( state.backtracking>0 ) { memoize(input, 14, enumDeclaration_StartIndex); }
   2115         }
   2116         dbg.location(419, 5);
   2117 
   2118         }
   2119         finally {
   2120             dbg.exitRule(getGrammarFileName(), "enumDeclaration");
   2121             decRuleLevel();
   2122             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2123         }
   2124 
   2125         return ;
   2126     }
   2127     // $ANTLR end "enumDeclaration"
   2128 
   2129 
   2130     // $ANTLR start "enumBody"
   2131     // src/com/google/doclava/parser/Java.g:422:1: enumBody : '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' ;
   2132     public final void enumBody() throws RecognitionException {
   2133         int enumBody_StartIndex = input.index();
   2134         try { dbg.enterRule(getGrammarFileName(), "enumBody");
   2135         if ( getRuleLevel()==0 ) {dbg.commence();}
   2136         incRuleLevel();
   2137         dbg.location(422, 1);
   2138 
   2139         try {
   2140             if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return ; }
   2141             // src/com/google/doclava/parser/Java.g:423:5: ( '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' )
   2142             dbg.enterAlt(1);
   2143 
   2144             // src/com/google/doclava/parser/Java.g:423:9: '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}'
   2145             {
   2146             dbg.location(423,9);
   2147             match(input,LBRACE,FOLLOW_LBRACE_in_enumBody1041); if (state.failed) return ;
   2148             dbg.location(424,9);
   2149             // src/com/google/doclava/parser/Java.g:424:9: ( enumConstants )?
   2150             int alt23=2;
   2151             try { dbg.enterSubRule(23);
   2152             try { dbg.enterDecision(23, decisionCanBacktrack[23]);
   2153 
   2154             int LA23_0 = input.LA(1);
   2155 
   2156             if ( (LA23_0==IDENTIFIER||LA23_0==MONKEYS_AT) ) {
   2157                 alt23=1;
   2158             }
   2159             } finally {dbg.exitDecision(23);}
   2160 
   2161             switch (alt23) {
   2162                 case 1 :
   2163                     dbg.enterAlt(1);
   2164 
   2165                     // src/com/google/doclava/parser/Java.g:424:10: enumConstants
   2166                     {
   2167                     dbg.location(424,10);
   2168                     pushFollow(FOLLOW_enumConstants_in_enumBody1052);
   2169                     enumConstants();
   2170 
   2171                     state._fsp--;
   2172                     if (state.failed) return ;
   2173 
   2174                     }
   2175                     break;
   2176 
   2177             }
   2178             } finally {dbg.exitSubRule(23);}
   2179 
   2180             dbg.location(426,9);
   2181             // src/com/google/doclava/parser/Java.g:426:9: ( ',' )?
   2182             int alt24=2;
   2183             try { dbg.enterSubRule(24);
   2184             try { dbg.enterDecision(24, decisionCanBacktrack[24]);
   2185 
   2186             int LA24_0 = input.LA(1);
   2187 
   2188             if ( (LA24_0==COMMA) ) {
   2189                 alt24=1;
   2190             }
   2191             } finally {dbg.exitDecision(24);}
   2192 
   2193             switch (alt24) {
   2194                 case 1 :
   2195                     dbg.enterAlt(1);
   2196 
   2197                     // src/com/google/doclava/parser/Java.g:0:0: ','
   2198                     {
   2199                     dbg.location(426,9);
   2200                     match(input,COMMA,FOLLOW_COMMA_in_enumBody1073); if (state.failed) return ;
   2201 
   2202                     }
   2203                     break;
   2204 
   2205             }
   2206             } finally {dbg.exitSubRule(24);}
   2207 
   2208             dbg.location(427,9);
   2209             // src/com/google/doclava/parser/Java.g:427:9: ( enumBodyDeclarations )?
   2210             int alt25=2;
   2211             try { dbg.enterSubRule(25);
   2212             try { dbg.enterDecision(25, decisionCanBacktrack[25]);
   2213 
   2214             int LA25_0 = input.LA(1);
   2215 
   2216             if ( (LA25_0==SEMI) ) {
   2217                 alt25=1;
   2218             }
   2219             } finally {dbg.exitDecision(25);}
   2220 
   2221             switch (alt25) {
   2222                 case 1 :
   2223                     dbg.enterAlt(1);
   2224 
   2225                     // src/com/google/doclava/parser/Java.g:427:10: enumBodyDeclarations
   2226                     {
   2227                     dbg.location(427,10);
   2228                     pushFollow(FOLLOW_enumBodyDeclarations_in_enumBody1085);
   2229                     enumBodyDeclarations();
   2230 
   2231                     state._fsp--;
   2232                     if (state.failed) return ;
   2233 
   2234                     }
   2235                     break;
   2236 
   2237             }
   2238             } finally {dbg.exitSubRule(25);}
   2239 
   2240             dbg.location(429,9);
   2241             match(input,RBRACE,FOLLOW_RBRACE_in_enumBody1106); if (state.failed) return ;
   2242 
   2243             }
   2244 
   2245         }
   2246         catch (RecognitionException re) {
   2247             reportError(re);
   2248             recover(input,re);
   2249         }
   2250         finally {
   2251             if ( state.backtracking>0 ) { memoize(input, 15, enumBody_StartIndex); }
   2252         }
   2253         dbg.location(430, 5);
   2254 
   2255         }
   2256         finally {
   2257             dbg.exitRule(getGrammarFileName(), "enumBody");
   2258             decRuleLevel();
   2259             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2260         }
   2261 
   2262         return ;
   2263     }
   2264     // $ANTLR end "enumBody"
   2265 
   2266 
   2267     // $ANTLR start "enumConstants"
   2268     // src/com/google/doclava/parser/Java.g:432:1: enumConstants : enumConstant ( ',' enumConstant )* ;
   2269     public final void enumConstants() throws RecognitionException {
   2270         int enumConstants_StartIndex = input.index();
   2271         try { dbg.enterRule(getGrammarFileName(), "enumConstants");
   2272         if ( getRuleLevel()==0 ) {dbg.commence();}
   2273         incRuleLevel();
   2274         dbg.location(432, 1);
   2275 
   2276         try {
   2277             if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return ; }
   2278             // src/com/google/doclava/parser/Java.g:433:5: ( enumConstant ( ',' enumConstant )* )
   2279             dbg.enterAlt(1);
   2280 
   2281             // src/com/google/doclava/parser/Java.g:433:9: enumConstant ( ',' enumConstant )*
   2282             {
   2283             dbg.location(433,9);
   2284             pushFollow(FOLLOW_enumConstant_in_enumConstants1125);
   2285             enumConstant();
   2286 
   2287             state._fsp--;
   2288             if (state.failed) return ;
   2289             dbg.location(434,9);
   2290             // src/com/google/doclava/parser/Java.g:434:9: ( ',' enumConstant )*
   2291             try { dbg.enterSubRule(26);
   2292 
   2293             loop26:
   2294             do {
   2295                 int alt26=2;
   2296                 try { dbg.enterDecision(26, decisionCanBacktrack[26]);
   2297 
   2298                 int LA26_0 = input.LA(1);
   2299 
   2300                 if ( (LA26_0==COMMA) ) {
   2301                     int LA26_1 = input.LA(2);
   2302 
   2303                     if ( (LA26_1==IDENTIFIER||LA26_1==MONKEYS_AT) ) {
   2304                         alt26=1;
   2305                     }
   2306 
   2307 
   2308                 }
   2309 
   2310 
   2311                 } finally {dbg.exitDecision(26);}
   2312 
   2313                 switch (alt26) {
   2314 		case 1 :
   2315 		    dbg.enterAlt(1);
   2316 
   2317 		    // src/com/google/doclava/parser/Java.g:434:10: ',' enumConstant
   2318 		    {
   2319 		    dbg.location(434,10);
   2320 		    match(input,COMMA,FOLLOW_COMMA_in_enumConstants1136); if (state.failed) return ;
   2321 		    dbg.location(434,14);
   2322 		    pushFollow(FOLLOW_enumConstant_in_enumConstants1138);
   2323 		    enumConstant();
   2324 
   2325 		    state._fsp--;
   2326 		    if (state.failed) return ;
   2327 
   2328 		    }
   2329 		    break;
   2330 
   2331 		default :
   2332 		    break loop26;
   2333                 }
   2334             } while (true);
   2335             } finally {dbg.exitSubRule(26);}
   2336 
   2337 
   2338             }
   2339 
   2340         }
   2341         catch (RecognitionException re) {
   2342             reportError(re);
   2343             recover(input,re);
   2344         }
   2345         finally {
   2346             if ( state.backtracking>0 ) { memoize(input, 16, enumConstants_StartIndex); }
   2347         }
   2348         dbg.location(436, 5);
   2349 
   2350         }
   2351         finally {
   2352             dbg.exitRule(getGrammarFileName(), "enumConstants");
   2353             decRuleLevel();
   2354             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2355         }
   2356 
   2357         return ;
   2358     }
   2359     // $ANTLR end "enumConstants"
   2360 
   2361 
   2362     // $ANTLR start "enumConstant"
   2363     // src/com/google/doclava/parser/Java.g:438:1: enumConstant : ( annotations )? IDENTIFIER ( arguments )? ( classBody )? ;
   2364     public final void enumConstant() throws RecognitionException {
   2365         int enumConstant_StartIndex = input.index();
   2366         try { dbg.enterRule(getGrammarFileName(), "enumConstant");
   2367         if ( getRuleLevel()==0 ) {dbg.commence();}
   2368         incRuleLevel();
   2369         dbg.location(438, 1);
   2370 
   2371         try {
   2372             if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return ; }
   2373             // src/com/google/doclava/parser/Java.g:443:5: ( ( annotations )? IDENTIFIER ( arguments )? ( classBody )? )
   2374             dbg.enterAlt(1);
   2375 
   2376             // src/com/google/doclava/parser/Java.g:443:9: ( annotations )? IDENTIFIER ( arguments )? ( classBody )?
   2377             {
   2378             dbg.location(443,9);
   2379             // src/com/google/doclava/parser/Java.g:443:9: ( annotations )?
   2380             int alt27=2;
   2381             try { dbg.enterSubRule(27);
   2382             try { dbg.enterDecision(27, decisionCanBacktrack[27]);
   2383 
   2384             int LA27_0 = input.LA(1);
   2385 
   2386             if ( (LA27_0==MONKEYS_AT) ) {
   2387                 alt27=1;
   2388             }
   2389             } finally {dbg.exitDecision(27);}
   2390 
   2391             switch (alt27) {
   2392                 case 1 :
   2393                     dbg.enterAlt(1);
   2394 
   2395                     // src/com/google/doclava/parser/Java.g:443:10: annotations
   2396                     {
   2397                     dbg.location(443,10);
   2398                     pushFollow(FOLLOW_annotations_in_enumConstant1171);
   2399                     annotations();
   2400 
   2401                     state._fsp--;
   2402                     if (state.failed) return ;
   2403 
   2404                     }
   2405                     break;
   2406 
   2407             }
   2408             } finally {dbg.exitSubRule(27);}
   2409 
   2410             dbg.location(445,9);
   2411             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumConstant1192); if (state.failed) return ;
   2412             dbg.location(446,9);
   2413             // src/com/google/doclava/parser/Java.g:446:9: ( arguments )?
   2414             int alt28=2;
   2415             try { dbg.enterSubRule(28);
   2416             try { dbg.enterDecision(28, decisionCanBacktrack[28]);
   2417 
   2418             int LA28_0 = input.LA(1);
   2419 
   2420             if ( (LA28_0==LPAREN) ) {
   2421                 alt28=1;
   2422             }
   2423             } finally {dbg.exitDecision(28);}
   2424 
   2425             switch (alt28) {
   2426                 case 1 :
   2427                     dbg.enterAlt(1);
   2428 
   2429                     // src/com/google/doclava/parser/Java.g:446:10: arguments
   2430                     {
   2431                     dbg.location(446,10);
   2432                     pushFollow(FOLLOW_arguments_in_enumConstant1203);
   2433                     arguments();
   2434 
   2435                     state._fsp--;
   2436                     if (state.failed) return ;
   2437 
   2438                     }
   2439                     break;
   2440 
   2441             }
   2442             } finally {dbg.exitSubRule(28);}
   2443 
   2444             dbg.location(448,9);
   2445             // src/com/google/doclava/parser/Java.g:448:9: ( classBody )?
   2446             int alt29=2;
   2447             try { dbg.enterSubRule(29);
   2448             try { dbg.enterDecision(29, decisionCanBacktrack[29]);
   2449 
   2450             int LA29_0 = input.LA(1);
   2451 
   2452             if ( (LA29_0==LBRACE) ) {
   2453                 alt29=1;
   2454             }
   2455             } finally {dbg.exitDecision(29);}
   2456 
   2457             switch (alt29) {
   2458                 case 1 :
   2459                     dbg.enterAlt(1);
   2460 
   2461                     // src/com/google/doclava/parser/Java.g:448:10: classBody
   2462                     {
   2463                     dbg.location(448,10);
   2464                     pushFollow(FOLLOW_classBody_in_enumConstant1225);
   2465                     classBody();
   2466 
   2467                     state._fsp--;
   2468                     if (state.failed) return ;
   2469 
   2470                     }
   2471                     break;
   2472 
   2473             }
   2474             } finally {dbg.exitSubRule(29);}
   2475 
   2476 
   2477             }
   2478 
   2479         }
   2480         catch (RecognitionException re) {
   2481             reportError(re);
   2482             recover(input,re);
   2483         }
   2484         finally {
   2485             if ( state.backtracking>0 ) { memoize(input, 17, enumConstant_StartIndex); }
   2486         }
   2487         dbg.location(452, 5);
   2488 
   2489         }
   2490         finally {
   2491             dbg.exitRule(getGrammarFileName(), "enumConstant");
   2492             decRuleLevel();
   2493             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2494         }
   2495 
   2496         return ;
   2497     }
   2498     // $ANTLR end "enumConstant"
   2499 
   2500 
   2501     // $ANTLR start "enumBodyDeclarations"
   2502     // src/com/google/doclava/parser/Java.g:454:1: enumBodyDeclarations : ';' ( classBodyDeclaration )* ;
   2503     public final void enumBodyDeclarations() throws RecognitionException {
   2504         int enumBodyDeclarations_StartIndex = input.index();
   2505         try { dbg.enterRule(getGrammarFileName(), "enumBodyDeclarations");
   2506         if ( getRuleLevel()==0 ) {dbg.commence();}
   2507         incRuleLevel();
   2508         dbg.location(454, 1);
   2509 
   2510         try {
   2511             if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return ; }
   2512             // src/com/google/doclava/parser/Java.g:455:5: ( ';' ( classBodyDeclaration )* )
   2513             dbg.enterAlt(1);
   2514 
   2515             // src/com/google/doclava/parser/Java.g:455:9: ';' ( classBodyDeclaration )*
   2516             {
   2517             dbg.location(455,9);
   2518             match(input,SEMI,FOLLOW_SEMI_in_enumBodyDeclarations1265); if (state.failed) return ;
   2519             dbg.location(456,9);
   2520             // src/com/google/doclava/parser/Java.g:456:9: ( classBodyDeclaration )*
   2521             try { dbg.enterSubRule(30);
   2522 
   2523             loop30:
   2524             do {
   2525                 int alt30=2;
   2526                 try { dbg.enterDecision(30, decisionCanBacktrack[30]);
   2527 
   2528                 int LA30_0 = input.LA(1);
   2529 
   2530                 if ( (LA30_0==IDENTIFIER||LA30_0==ABSTRACT||LA30_0==BOOLEAN||LA30_0==BYTE||(LA30_0>=CHAR && LA30_0<=CLASS)||LA30_0==DOUBLE||LA30_0==ENUM||LA30_0==FINAL||LA30_0==FLOAT||(LA30_0>=INT && LA30_0<=NATIVE)||(LA30_0>=PRIVATE && LA30_0<=PUBLIC)||(LA30_0>=SHORT && LA30_0<=STRICTFP)||LA30_0==SYNCHRONIZED||LA30_0==TRANSIENT||(LA30_0>=VOID && LA30_0<=VOLATILE)||LA30_0==LBRACE||LA30_0==SEMI||LA30_0==MONKEYS_AT||LA30_0==LT) ) {
   2531                     alt30=1;
   2532                 }
   2533 
   2534 
   2535                 } finally {dbg.exitDecision(30);}
   2536 
   2537                 switch (alt30) {
   2538 		case 1 :
   2539 		    dbg.enterAlt(1);
   2540 
   2541 		    // src/com/google/doclava/parser/Java.g:456:10: classBodyDeclaration
   2542 		    {
   2543 		    dbg.location(456,10);
   2544 		    pushFollow(FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1276);
   2545 		    classBodyDeclaration();
   2546 
   2547 		    state._fsp--;
   2548 		    if (state.failed) return ;
   2549 
   2550 		    }
   2551 		    break;
   2552 
   2553 		default :
   2554 		    break loop30;
   2555                 }
   2556             } while (true);
   2557             } finally {dbg.exitSubRule(30);}
   2558 
   2559 
   2560             }
   2561 
   2562         }
   2563         catch (RecognitionException re) {
   2564             reportError(re);
   2565             recover(input,re);
   2566         }
   2567         finally {
   2568             if ( state.backtracking>0 ) { memoize(input, 18, enumBodyDeclarations_StartIndex); }
   2569         }
   2570         dbg.location(458, 5);
   2571 
   2572         }
   2573         finally {
   2574             dbg.exitRule(getGrammarFileName(), "enumBodyDeclarations");
   2575             decRuleLevel();
   2576             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2577         }
   2578 
   2579         return ;
   2580     }
   2581     // $ANTLR end "enumBodyDeclarations"
   2582 
   2583 
   2584     // $ANTLR start "interfaceDeclaration"
   2585     // src/com/google/doclava/parser/Java.g:460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );
   2586     public final void interfaceDeclaration() throws RecognitionException {
   2587         int interfaceDeclaration_StartIndex = input.index();
   2588         try { dbg.enterRule(getGrammarFileName(), "interfaceDeclaration");
   2589         if ( getRuleLevel()==0 ) {dbg.commence();}
   2590         incRuleLevel();
   2591         dbg.location(460, 1);
   2592 
   2593         try {
   2594             if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return ; }
   2595             // src/com/google/doclava/parser/Java.g:461:5: ( normalInterfaceDeclaration | annotationTypeDeclaration )
   2596             int alt31=2;
   2597             try { dbg.enterDecision(31, decisionCanBacktrack[31]);
   2598 
   2599             try {
   2600                 isCyclicDecision = true;
   2601                 alt31 = dfa31.predict(input);
   2602             }
   2603             catch (NoViableAltException nvae) {
   2604                 dbg.recognitionException(nvae);
   2605                 throw nvae;
   2606             }
   2607             } finally {dbg.exitDecision(31);}
   2608 
   2609             switch (alt31) {
   2610                 case 1 :
   2611                     dbg.enterAlt(1);
   2612 
   2613                     // src/com/google/doclava/parser/Java.g:461:9: normalInterfaceDeclaration
   2614                     {
   2615                     dbg.location(461,9);
   2616                     pushFollow(FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1306);
   2617                     normalInterfaceDeclaration();
   2618 
   2619                     state._fsp--;
   2620                     if (state.failed) return ;
   2621 
   2622                     }
   2623                     break;
   2624                 case 2 :
   2625                     dbg.enterAlt(2);
   2626 
   2627                     // src/com/google/doclava/parser/Java.g:462:9: annotationTypeDeclaration
   2628                     {
   2629                     dbg.location(462,9);
   2630                     pushFollow(FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1316);
   2631                     annotationTypeDeclaration();
   2632 
   2633                     state._fsp--;
   2634                     if (state.failed) return ;
   2635 
   2636                     }
   2637                     break;
   2638 
   2639             }
   2640         }
   2641         catch (RecognitionException re) {
   2642             reportError(re);
   2643             recover(input,re);
   2644         }
   2645         finally {
   2646             if ( state.backtracking>0 ) { memoize(input, 19, interfaceDeclaration_StartIndex); }
   2647         }
   2648         dbg.location(463, 5);
   2649 
   2650         }
   2651         finally {
   2652             dbg.exitRule(getGrammarFileName(), "interfaceDeclaration");
   2653             decRuleLevel();
   2654             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2655         }
   2656 
   2657         return ;
   2658     }
   2659     // $ANTLR end "interfaceDeclaration"
   2660 
   2661 
   2662     // $ANTLR start "normalInterfaceDeclaration"
   2663     // src/com/google/doclava/parser/Java.g:465:1: normalInterfaceDeclaration : modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody ;
   2664     public final void normalInterfaceDeclaration() throws RecognitionException {
   2665         int normalInterfaceDeclaration_StartIndex = input.index();
   2666         try { dbg.enterRule(getGrammarFileName(), "normalInterfaceDeclaration");
   2667         if ( getRuleLevel()==0 ) {dbg.commence();}
   2668         incRuleLevel();
   2669         dbg.location(465, 1);
   2670 
   2671         try {
   2672             if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return ; }
   2673             // src/com/google/doclava/parser/Java.g:466:5: ( modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody )
   2674             dbg.enterAlt(1);
   2675 
   2676             // src/com/google/doclava/parser/Java.g:466:9: modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody
   2677             {
   2678             dbg.location(466,9);
   2679             pushFollow(FOLLOW_modifiers_in_normalInterfaceDeclaration1335);
   2680             modifiers();
   2681 
   2682             state._fsp--;
   2683             if (state.failed) return ;
   2684             dbg.location(466,19);
   2685             match(input,INTERFACE,FOLLOW_INTERFACE_in_normalInterfaceDeclaration1337); if (state.failed) return ;
   2686             dbg.location(466,31);
   2687             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1339); if (state.failed) return ;
   2688             dbg.location(467,9);
   2689             // src/com/google/doclava/parser/Java.g:467:9: ( typeParameters )?
   2690             int alt32=2;
   2691             try { dbg.enterSubRule(32);
   2692             try { dbg.enterDecision(32, decisionCanBacktrack[32]);
   2693 
   2694             int LA32_0 = input.LA(1);
   2695 
   2696             if ( (LA32_0==LT) ) {
   2697                 alt32=1;
   2698             }
   2699             } finally {dbg.exitDecision(32);}
   2700 
   2701             switch (alt32) {
   2702                 case 1 :
   2703                     dbg.enterAlt(1);
   2704 
   2705                     // src/com/google/doclava/parser/Java.g:467:10: typeParameters
   2706                     {
   2707                     dbg.location(467,10);
   2708                     pushFollow(FOLLOW_typeParameters_in_normalInterfaceDeclaration1350);
   2709                     typeParameters();
   2710 
   2711                     state._fsp--;
   2712                     if (state.failed) return ;
   2713 
   2714                     }
   2715                     break;
   2716 
   2717             }
   2718             } finally {dbg.exitSubRule(32);}
   2719 
   2720             dbg.location(469,9);
   2721             // src/com/google/doclava/parser/Java.g:469:9: ( 'extends' typeList )?
   2722             int alt33=2;
   2723             try { dbg.enterSubRule(33);
   2724             try { dbg.enterDecision(33, decisionCanBacktrack[33]);
   2725 
   2726             int LA33_0 = input.LA(1);
   2727 
   2728             if ( (LA33_0==EXTENDS) ) {
   2729                 alt33=1;
   2730             }
   2731             } finally {dbg.exitDecision(33);}
   2732 
   2733             switch (alt33) {
   2734                 case 1 :
   2735                     dbg.enterAlt(1);
   2736 
   2737                     // src/com/google/doclava/parser/Java.g:469:10: 'extends' typeList
   2738                     {
   2739                     dbg.location(469,10);
   2740                     match(input,EXTENDS,FOLLOW_EXTENDS_in_normalInterfaceDeclaration1372); if (state.failed) return ;
   2741                     dbg.location(469,20);
   2742                     pushFollow(FOLLOW_typeList_in_normalInterfaceDeclaration1374);
   2743                     typeList();
   2744 
   2745                     state._fsp--;
   2746                     if (state.failed) return ;
   2747 
   2748                     }
   2749                     break;
   2750 
   2751             }
   2752             } finally {dbg.exitSubRule(33);}
   2753 
   2754             dbg.location(471,9);
   2755             pushFollow(FOLLOW_interfaceBody_in_normalInterfaceDeclaration1395);
   2756             interfaceBody();
   2757 
   2758             state._fsp--;
   2759             if (state.failed) return ;
   2760 
   2761             }
   2762 
   2763         }
   2764         catch (RecognitionException re) {
   2765             reportError(re);
   2766             recover(input,re);
   2767         }
   2768         finally {
   2769             if ( state.backtracking>0 ) { memoize(input, 20, normalInterfaceDeclaration_StartIndex); }
   2770         }
   2771         dbg.location(472, 5);
   2772 
   2773         }
   2774         finally {
   2775             dbg.exitRule(getGrammarFileName(), "normalInterfaceDeclaration");
   2776             decRuleLevel();
   2777             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2778         }
   2779 
   2780         return ;
   2781     }
   2782     // $ANTLR end "normalInterfaceDeclaration"
   2783 
   2784 
   2785     // $ANTLR start "typeList"
   2786     // src/com/google/doclava/parser/Java.g:474:1: typeList : type ( ',' type )* ;
   2787     public final void typeList() throws RecognitionException {
   2788         int typeList_StartIndex = input.index();
   2789         try { dbg.enterRule(getGrammarFileName(), "typeList");
   2790         if ( getRuleLevel()==0 ) {dbg.commence();}
   2791         incRuleLevel();
   2792         dbg.location(474, 1);
   2793 
   2794         try {
   2795             if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return ; }
   2796             // src/com/google/doclava/parser/Java.g:475:5: ( type ( ',' type )* )
   2797             dbg.enterAlt(1);
   2798 
   2799             // src/com/google/doclava/parser/Java.g:475:9: type ( ',' type )*
   2800             {
   2801             dbg.location(475,9);
   2802             pushFollow(FOLLOW_type_in_typeList1414);
   2803             type();
   2804 
   2805             state._fsp--;
   2806             if (state.failed) return ;
   2807             dbg.location(476,9);
   2808             // src/com/google/doclava/parser/Java.g:476:9: ( ',' type )*
   2809             try { dbg.enterSubRule(34);
   2810 
   2811             loop34:
   2812             do {
   2813                 int alt34=2;
   2814                 try { dbg.enterDecision(34, decisionCanBacktrack[34]);
   2815 
   2816                 int LA34_0 = input.LA(1);
   2817 
   2818                 if ( (LA34_0==COMMA) ) {
   2819                     alt34=1;
   2820                 }
   2821 
   2822 
   2823                 } finally {dbg.exitDecision(34);}
   2824 
   2825                 switch (alt34) {
   2826 		case 1 :
   2827 		    dbg.enterAlt(1);
   2828 
   2829 		    // src/com/google/doclava/parser/Java.g:476:10: ',' type
   2830 		    {
   2831 		    dbg.location(476,10);
   2832 		    match(input,COMMA,FOLLOW_COMMA_in_typeList1425); if (state.failed) return ;
   2833 		    dbg.location(476,14);
   2834 		    pushFollow(FOLLOW_type_in_typeList1427);
   2835 		    type();
   2836 
   2837 		    state._fsp--;
   2838 		    if (state.failed) return ;
   2839 
   2840 		    }
   2841 		    break;
   2842 
   2843 		default :
   2844 		    break loop34;
   2845                 }
   2846             } while (true);
   2847             } finally {dbg.exitSubRule(34);}
   2848 
   2849 
   2850             }
   2851 
   2852         }
   2853         catch (RecognitionException re) {
   2854             reportError(re);
   2855             recover(input,re);
   2856         }
   2857         finally {
   2858             if ( state.backtracking>0 ) { memoize(input, 21, typeList_StartIndex); }
   2859         }
   2860         dbg.location(478, 5);
   2861 
   2862         }
   2863         finally {
   2864             dbg.exitRule(getGrammarFileName(), "typeList");
   2865             decRuleLevel();
   2866             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2867         }
   2868 
   2869         return ;
   2870     }
   2871     // $ANTLR end "typeList"
   2872 
   2873 
   2874     // $ANTLR start "classBody"
   2875     // src/com/google/doclava/parser/Java.g:480:1: classBody : '{' ( classBodyDeclaration )* '}' ;
   2876     public final void classBody() throws RecognitionException {
   2877         int classBody_StartIndex = input.index();
   2878         try { dbg.enterRule(getGrammarFileName(), "classBody");
   2879         if ( getRuleLevel()==0 ) {dbg.commence();}
   2880         incRuleLevel();
   2881         dbg.location(480, 1);
   2882 
   2883         try {
   2884             if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return ; }
   2885             // src/com/google/doclava/parser/Java.g:481:5: ( '{' ( classBodyDeclaration )* '}' )
   2886             dbg.enterAlt(1);
   2887 
   2888             // src/com/google/doclava/parser/Java.g:481:9: '{' ( classBodyDeclaration )* '}'
   2889             {
   2890             dbg.location(481,9);
   2891             match(input,LBRACE,FOLLOW_LBRACE_in_classBody1457); if (state.failed) return ;
   2892             dbg.location(482,9);
   2893             // src/com/google/doclava/parser/Java.g:482:9: ( classBodyDeclaration )*
   2894             try { dbg.enterSubRule(35);
   2895 
   2896             loop35:
   2897             do {
   2898                 int alt35=2;
   2899                 try { dbg.enterDecision(35, decisionCanBacktrack[35]);
   2900 
   2901                 int LA35_0 = input.LA(1);
   2902 
   2903                 if ( (LA35_0==IDENTIFIER||LA35_0==ABSTRACT||LA35_0==BOOLEAN||LA35_0==BYTE||(LA35_0>=CHAR && LA35_0<=CLASS)||LA35_0==DOUBLE||LA35_0==ENUM||LA35_0==FINAL||LA35_0==FLOAT||(LA35_0>=INT && LA35_0<=NATIVE)||(LA35_0>=PRIVATE && LA35_0<=PUBLIC)||(LA35_0>=SHORT && LA35_0<=STRICTFP)||LA35_0==SYNCHRONIZED||LA35_0==TRANSIENT||(LA35_0>=VOID && LA35_0<=VOLATILE)||LA35_0==LBRACE||LA35_0==SEMI||LA35_0==MONKEYS_AT||LA35_0==LT) ) {
   2904                     alt35=1;
   2905                 }
   2906 
   2907 
   2908                 } finally {dbg.exitDecision(35);}
   2909 
   2910                 switch (alt35) {
   2911 		case 1 :
   2912 		    dbg.enterAlt(1);
   2913 
   2914 		    // src/com/google/doclava/parser/Java.g:482:10: classBodyDeclaration
   2915 		    {
   2916 		    dbg.location(482,10);
   2917 		    pushFollow(FOLLOW_classBodyDeclaration_in_classBody1468);
   2918 		    classBodyDeclaration();
   2919 
   2920 		    state._fsp--;
   2921 		    if (state.failed) return ;
   2922 
   2923 		    }
   2924 		    break;
   2925 
   2926 		default :
   2927 		    break loop35;
   2928                 }
   2929             } while (true);
   2930             } finally {dbg.exitSubRule(35);}
   2931 
   2932             dbg.location(484,9);
   2933             match(input,RBRACE,FOLLOW_RBRACE_in_classBody1489); if (state.failed) return ;
   2934 
   2935             }
   2936 
   2937         }
   2938         catch (RecognitionException re) {
   2939             reportError(re);
   2940             recover(input,re);
   2941         }
   2942         finally {
   2943             if ( state.backtracking>0 ) { memoize(input, 22, classBody_StartIndex); }
   2944         }
   2945         dbg.location(485, 5);
   2946 
   2947         }
   2948         finally {
   2949             dbg.exitRule(getGrammarFileName(), "classBody");
   2950             decRuleLevel();
   2951             if ( getRuleLevel()==0 ) {dbg.terminate();}
   2952         }
   2953 
   2954         return ;
   2955     }
   2956     // $ANTLR end "classBody"
   2957 
   2958 
   2959     // $ANTLR start "interfaceBody"
   2960     // src/com/google/doclava/parser/Java.g:487:1: interfaceBody : '{' ( interfaceBodyDeclaration )* '}' ;
   2961     public final void interfaceBody() throws RecognitionException {
   2962         int interfaceBody_StartIndex = input.index();
   2963         try { dbg.enterRule(getGrammarFileName(), "interfaceBody");
   2964         if ( getRuleLevel()==0 ) {dbg.commence();}
   2965         incRuleLevel();
   2966         dbg.location(487, 1);
   2967 
   2968         try {
   2969             if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return ; }
   2970             // src/com/google/doclava/parser/Java.g:488:5: ( '{' ( interfaceBodyDeclaration )* '}' )
   2971             dbg.enterAlt(1);
   2972 
   2973             // src/com/google/doclava/parser/Java.g:488:9: '{' ( interfaceBodyDeclaration )* '}'
   2974             {
   2975             dbg.location(488,9);
   2976             match(input,LBRACE,FOLLOW_LBRACE_in_interfaceBody1508); if (state.failed) return ;
   2977             dbg.location(489,9);
   2978             // src/com/google/doclava/parser/Java.g:489:9: ( interfaceBodyDeclaration )*
   2979             try { dbg.enterSubRule(36);
   2980 
   2981             loop36:
   2982             do {
   2983                 int alt36=2;
   2984                 try { dbg.enterDecision(36, decisionCanBacktrack[36]);
   2985 
   2986                 int LA36_0 = input.LA(1);
   2987 
   2988                 if ( (LA36_0==IDENTIFIER||LA36_0==ABSTRACT||LA36_0==BOOLEAN||LA36_0==BYTE||(LA36_0>=CHAR && LA36_0<=CLASS)||LA36_0==DOUBLE||LA36_0==ENUM||LA36_0==FINAL||LA36_0==FLOAT||(LA36_0>=INT && LA36_0<=NATIVE)||(LA36_0>=PRIVATE && LA36_0<=PUBLIC)||(LA36_0>=SHORT && LA36_0<=STRICTFP)||LA36_0==SYNCHRONIZED||LA36_0==TRANSIENT||(LA36_0>=VOID && LA36_0<=VOLATILE)||LA36_0==SEMI||LA36_0==MONKEYS_AT||LA36_0==LT) ) {
   2989                     alt36=1;
   2990                 }
   2991 
   2992 
   2993                 } finally {dbg.exitDecision(36);}
   2994 
   2995                 switch (alt36) {
   2996 		case 1 :
   2997 		    dbg.enterAlt(1);
   2998 
   2999 		    // src/com/google/doclava/parser/Java.g:489:10: interfaceBodyDeclaration
   3000 		    {
   3001 		    dbg.location(489,10);
   3002 		    pushFollow(FOLLOW_interfaceBodyDeclaration_in_interfaceBody1519);
   3003 		    interfaceBodyDeclaration();
   3004 
   3005 		    state._fsp--;
   3006 		    if (state.failed) return ;
   3007 
   3008 		    }
   3009 		    break;
   3010 
   3011 		default :
   3012 		    break loop36;
   3013                 }
   3014             } while (true);
   3015             } finally {dbg.exitSubRule(36);}
   3016 
   3017             dbg.location(491,9);
   3018             match(input,RBRACE,FOLLOW_RBRACE_in_interfaceBody1540); if (state.failed) return ;
   3019 
   3020             }
   3021 
   3022         }
   3023         catch (RecognitionException re) {
   3024             reportError(re);
   3025             recover(input,re);
   3026         }
   3027         finally {
   3028             if ( state.backtracking>0 ) { memoize(input, 23, interfaceBody_StartIndex); }
   3029         }
   3030         dbg.location(492, 5);
   3031 
   3032         }
   3033         finally {
   3034             dbg.exitRule(getGrammarFileName(), "interfaceBody");
   3035             decRuleLevel();
   3036             if ( getRuleLevel()==0 ) {dbg.terminate();}
   3037         }
   3038 
   3039         return ;
   3040     }
   3041     // $ANTLR end "interfaceBody"
   3042 
   3043 
   3044     // $ANTLR start "classBodyDeclaration"
   3045     // src/com/google/doclava/parser/Java.g:494:1: classBodyDeclaration : ( ';' | ( 'static' )? block | memberDecl );
   3046     public final void classBodyDeclaration() throws RecognitionException {
   3047         int classBodyDeclaration_StartIndex = input.index();
   3048         try { dbg.enterRule(getGrammarFileName(), "classBodyDeclaration");
   3049         if ( getRuleLevel()==0 ) {dbg.commence();}
   3050         incRuleLevel();
   3051         dbg.location(494, 1);
   3052 
   3053         try {
   3054             if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return ; }
   3055             // src/com/google/doclava/parser/Java.g:495:5: ( ';' | ( 'static' )? block | memberDecl )
   3056             int alt38=3;
   3057             try { dbg.enterDecision(38, decisionCanBacktrack[38]);
   3058 
   3059             switch ( input.LA(1) ) {
   3060             case SEMI:
   3061                 {
   3062                 alt38=1;
   3063                 }
   3064                 break;
   3065             case STATIC:
   3066                 {
   3067                 int LA38_2 = input.LA(2);
   3068 
   3069                 if ( (LA38_2==LBRACE) ) {
   3070                     alt38=2;
   3071                 }
   3072                 else if ( (LA38_2==IDENTIFIER||LA38_2==ABSTRACT||LA38_2==BOOLEAN||LA38_2==BYTE||(LA38_2>=CHAR && LA38_2<=CLASS)||LA38_2==DOUBLE||LA38_2==ENUM||LA38_2==FINAL||LA38_2==FLOAT||(LA38_2>=INT && LA38_2<=NATIVE)||(LA38_2>=PRIVATE && LA38_2<=PUBLIC)||(LA38_2>=SHORT && LA38_2<=STRICTFP)||LA38_2==SYNCHRONIZED||LA38_2==TRANSIENT||(LA38_2>=VOID && LA38_2<=VOLATILE)||LA38_2==MONKEYS_AT||LA38_2==LT) ) {
   3073                     alt38=3;
   3074                 }
   3075                 else {
   3076                     if (state.backtracking>0) {state.failed=true; return ;}
   3077                     NoViableAltException nvae =
   3078                         new NoViableAltException("", 38, 2, input);
   3079 
   3080                     dbg.recognitionException(nvae);
   3081                     throw nvae;
   3082                 }
   3083                 }
   3084                 break;
   3085             case LBRACE:
   3086                 {
   3087                 alt38=2;
   3088                 }
   3089                 break;
   3090             case IDENTIFIER:
   3091             case ABSTRACT:
   3092             case BOOLEAN:
   3093             case BYTE:
   3094             case CHAR:
   3095             case CLASS:
   3096             case DOUBLE:
   3097             case ENUM:
   3098             case FINAL:
   3099             case FLOAT:
   3100             case INT:
   3101             case INTERFACE:
   3102             case LONG:
   3103             case NATIVE:
   3104             case PRIVATE:
   3105             case PROTECTED:
   3106             case PUBLIC:
   3107             case SHORT:
   3108             case STRICTFP:
   3109             case SYNCHRONIZED:
   3110             case TRANSIENT:
   3111             case VOID:
   3112             case VOLATILE:
   3113             case MONKEYS_AT:
   3114             case LT:
   3115                 {
   3116                 alt38=3;
   3117                 }
   3118                 break;
   3119             default:
   3120                 if (state.backtracking>0) {state.failed=true; return ;}
   3121                 NoViableAltException nvae =
   3122                     new NoViableAltException("", 38, 0, input);
   3123 
   3124                 dbg.recognitionException(nvae);
   3125                 throw nvae;
   3126             }
   3127 
   3128             } finally {dbg.exitDecision(38);}
   3129 
   3130             switch (alt38) {
   3131                 case 1 :
   3132                     dbg.enterAlt(1);
   3133 
   3134                     // src/com/google/doclava/parser/Java.g:495:9: ';'
   3135                     {
   3136                     dbg.location(495,9);
   3137                     match(input,SEMI,FOLLOW_SEMI_in_classBodyDeclaration1559); if (state.failed) return ;
   3138 
   3139                     }
   3140                     break;
   3141                 case 2 :
   3142                     dbg.enterAlt(2);
   3143 
   3144                     // src/com/google/doclava/parser/Java.g:496:9: ( 'static' )? block
   3145                     {
   3146                     dbg.location(496,9);
   3147                     // src/com/google/doclava/parser/Java.g:496:9: ( 'static' )?
   3148                     int alt37=2;
   3149                     try { dbg.enterSubRule(37);
   3150                     try { dbg.enterDecision(37, decisionCanBacktrack[37]);
   3151 
   3152                     int LA37_0 = input.LA(1);
   3153 
   3154                     if ( (LA37_0==STATIC) ) {
   3155                         alt37=1;
   3156                     }
   3157                     } finally {dbg.exitDecision(37);}
   3158 
   3159                     switch (alt37) {
   3160                         case 1 :
   3161                             dbg.enterAlt(1);
   3162 
   3163                             // src/com/google/doclava/parser/Java.g:496:10: 'static'
   3164                             {
   3165                             dbg.location(496,10);
   3166                             match(input,STATIC,FOLLOW_STATIC_in_classBodyDeclaration1570); if (state.failed) return ;
   3167 
   3168                             }
   3169                             break;
   3170 
   3171                     }
   3172                     } finally {dbg.exitSubRule(37);}
   3173 
   3174                     dbg.location(498,9);
   3175                     pushFollow(FOLLOW_block_in_classBodyDeclaration1591);
   3176                     block();
   3177 
   3178                     state._fsp--;
   3179                     if (state.failed) return ;
   3180 
   3181                     }
   3182                     break;
   3183                 case 3 :
   3184                     dbg.enterAlt(3);
   3185 
   3186                     // src/com/google/doclava/parser/Java.g:499:9: memberDecl
   3187                     {
   3188                     dbg.location(499,9);
   3189                     pushFollow(FOLLOW_memberDecl_in_classBodyDeclaration1601);
   3190                     memberDecl();
   3191 
   3192                     state._fsp--;
   3193                     if (state.failed) return ;
   3194 
   3195                     }
   3196                     break;
   3197 
   3198             }
   3199         }
   3200         catch (RecognitionException re) {
   3201             reportError(re);
   3202             recover(input,re);
   3203         }
   3204         finally {
   3205             if ( state.backtracking>0 ) { memoize(input, 24, classBodyDeclaration_StartIndex); }
   3206         }
   3207         dbg.location(500, 5);
   3208 
   3209         }
   3210         finally {
   3211             dbg.exitRule(getGrammarFileName(), "classBodyDeclaration");
   3212             decRuleLevel();
   3213             if ( getRuleLevel()==0 ) {dbg.terminate();}
   3214         }
   3215 
   3216         return ;
   3217     }
   3218     // $ANTLR end "classBodyDeclaration"
   3219 
   3220 
   3221     // $ANTLR start "memberDecl"
   3222     // src/com/google/doclava/parser/Java.g:502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );
   3223     public final void memberDecl() throws RecognitionException {
   3224         int memberDecl_StartIndex = input.index();
   3225         try { dbg.enterRule(getGrammarFileName(), "memberDecl");
   3226         if ( getRuleLevel()==0 ) {dbg.commence();}
   3227         incRuleLevel();
   3228         dbg.location(502, 1);
   3229 
   3230         try {
   3231             if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return ; }
   3232             // src/com/google/doclava/parser/Java.g:503:5: ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration )
   3233             int alt39=4;
   3234             try { dbg.enterDecision(39, decisionCanBacktrack[39]);
   3235 
   3236             try {
   3237                 isCyclicDecision = true;
   3238                 alt39 = dfa39.predict(input);
   3239             }
   3240             catch (NoViableAltException nvae) {
   3241                 dbg.recognitionException(nvae);
   3242                 throw nvae;
   3243             }
   3244             } finally {dbg.exitDecision(39);}
   3245 
   3246             switch (alt39) {
   3247                 case 1 :
   3248                     dbg.enterAlt(1);
   3249 
   3250                     // src/com/google/doclava/parser/Java.g:503:10: fieldDeclaration
   3251                     {
   3252                     dbg.location(503,10);
   3253                     pushFollow(FOLLOW_fieldDeclaration_in_memberDecl1621);
   3254                     fieldDeclaration();
   3255 
   3256                     state._fsp--;
   3257                     if (state.failed) return ;
   3258 
   3259                     }
   3260                     break;
   3261                 case 2 :
   3262                     dbg.enterAlt(2);
   3263 
   3264                     // src/com/google/doclava/parser/Java.g:504:10: methodDeclaration
   3265                     {
   3266                     dbg.location(504,10);
   3267                     pushFollow(FOLLOW_methodDeclaration_in_memberDecl1632);
   3268                     methodDeclaration();
   3269 
   3270                     state._fsp--;
   3271                     if (state.failed) return ;
   3272 
   3273                     }
   3274                     break;
   3275                 case 3 :
   3276                     dbg.enterAlt(3);
   3277 
   3278                     // src/com/google/doclava/parser/Java.g:505:10: classDeclaration
   3279                     {
   3280                     dbg.location(505,10);
   3281                     pushFollow(FOLLOW_classDeclaration_in_memberDecl1643);
   3282                     classDeclaration();
   3283 
   3284                     state._fsp--;
   3285                     if (state.failed) return ;
   3286 
   3287                     }
   3288                     break;
   3289                 case 4 :
   3290                     dbg.enterAlt(4);
   3291 
   3292                     // src/com/google/doclava/parser/Java.g:506:10: interfaceDeclaration
   3293                     {
   3294                     dbg.location(506,10);
   3295                     pushFollow(FOLLOW_interfaceDeclaration_in_memberDecl1654);
   3296                     interfaceDeclaration();
   3297 
   3298                     state._fsp--;
   3299                     if (state.failed) return ;
   3300 
   3301                     }
   3302                     break;
   3303 
   3304             }
   3305         }
   3306         catch (RecognitionException re) {
   3307             reportError(re);
   3308             recover(input,re);
   3309         }
   3310         finally {
   3311             if ( state.backtracking>0 ) { memoize(input, 25, memberDecl_StartIndex); }
   3312         }
   3313         dbg.location(507, 5);
   3314 
   3315         }
   3316         finally {
   3317             dbg.exitRule(getGrammarFileName(), "memberDecl");
   3318             decRuleLevel();
   3319             if ( getRuleLevel()==0 ) {dbg.terminate();}
   3320         }
   3321 
   3322         return ;
   3323     }
   3324     // $ANTLR end "memberDecl"
   3325 
   3326 
   3327     // $ANTLR start "methodDeclaration"
   3328     // src/com/google/doclava/parser/Java.g:510:1: methodDeclaration : ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) );
   3329     public final void methodDeclaration() throws RecognitionException {
   3330         int methodDeclaration_StartIndex = input.index();
   3331         try { dbg.enterRule(getGrammarFileName(), "methodDeclaration");
   3332         if ( getRuleLevel()==0 ) {dbg.commence();}
   3333         incRuleLevel();
   3334         dbg.location(510, 1);
   3335 
   3336         try {
   3337             if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return ; }
   3338             // src/com/google/doclava/parser/Java.g:511:5: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) )
   3339             int alt49=2;
   3340             try { dbg.enterDecision(49, decisionCanBacktrack[49]);
   3341 
   3342             try {
   3343                 isCyclicDecision = true;
   3344                 alt49 = dfa49.predict(input);
   3345             }
   3346             catch (NoViableAltException nvae) {
   3347                 dbg.recognitionException(nvae);
   3348                 throw nvae;
   3349             }
   3350             } finally {dbg.exitDecision(49);}
   3351 
   3352             switch (alt49) {
   3353                 case 1 :
   3354                     dbg.enterAlt(1);
   3355 
   3356                     // src/com/google/doclava/parser/Java.g:513:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}'
   3357                     {
   3358                     dbg.location(513,10);
   3359                     pushFollow(FOLLOW_modifiers_in_methodDeclaration1691);
   3360                     modifiers();
   3361 
   3362                     state._fsp--;
   3363                     if (state.failed) return ;
   3364                     dbg.location(514,9);
   3365                     // src/com/google/doclava/parser/Java.g:514:9: ( typeParameters )?
   3366                     int alt40=2;
   3367                     try { dbg.enterSubRule(40);
   3368                     try { dbg.enterDecision(40, decisionCanBacktrack[40]);
   3369 
   3370                     int LA40_0 = input.LA(1);
   3371 
   3372                     if ( (LA40_0==LT) ) {
   3373                         alt40=1;
   3374                     }
   3375                     } finally {dbg.exitDecision(40);}
   3376 
   3377                     switch (alt40) {
   3378                         case 1 :
   3379                             dbg.enterAlt(1);
   3380 
   3381                             // src/com/google/doclava/parser/Java.g:514:10: typeParameters
   3382                             {
   3383                             dbg.location(514,10);
   3384                             pushFollow(FOLLOW_typeParameters_in_methodDeclaration1702);
   3385                             typeParameters();
   3386 
   3387                             state._fsp--;
   3388                             if (state.failed) return ;
   3389 
   3390                             }
   3391                             break;
   3392 
   3393                     }
   3394                     } finally {dbg.exitSubRule(40);}
   3395 
   3396                     dbg.location(516,9);
   3397                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration1723); if (state.failed) return ;
   3398                     dbg.location(517,9);
   3399                     pushFollow(FOLLOW_formalParameters_in_methodDeclaration1733);
   3400                     formalParameters();
   3401 
   3402                     state._fsp--;
   3403                     if (state.failed) return ;
   3404                     dbg.location(518,9);
   3405                     // src/com/google/doclava/parser/Java.g:518:9: ( 'throws' qualifiedNameList )?
   3406                     int alt41=2;
   3407                     try { dbg.enterSubRule(41);
   3408                     try { dbg.enterDecision(41, decisionCanBacktrack[41]);
   3409 
   3410                     int LA41_0 = input.LA(1);
   3411 
   3412                     if ( (LA41_0==THROWS) ) {
   3413                         alt41=1;
   3414                     }
   3415                     } finally {dbg.exitDecision(41);}
   3416 
   3417                     switch (alt41) {
   3418                         case 1 :
   3419                             dbg.enterAlt(1);
   3420 
   3421                             // src/com/google/doclava/parser/Java.g:518:10: 'throws' qualifiedNameList
   3422                             {
   3423                             dbg.location(518,10);
   3424                             match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration1744); if (state.failed) return ;
   3425                             dbg.location(518,19);
   3426                             pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration1746);
   3427                             qualifiedNameList();
   3428 
   3429                             state._fsp--;
   3430                             if (state.failed) return ;
   3431 
   3432                             }
   3433                             break;
   3434 
   3435                     }
   3436                     } finally {dbg.exitSubRule(41);}
   3437 
   3438                     dbg.location(520,9);
   3439                     match(input,LBRACE,FOLLOW_LBRACE_in_methodDeclaration1767); if (state.failed) return ;
   3440                     dbg.location(521,9);
   3441                     // src/com/google/doclava/parser/Java.g:521:9: ( explicitConstructorInvocation )?
   3442                     int alt42=2;
   3443                     try { dbg.enterSubRule(42);
   3444                     try { dbg.enterDecision(42, decisionCanBacktrack[42]);
   3445 
   3446                     try {
   3447                         isCyclicDecision = true;
   3448                         alt42 = dfa42.predict(input);
   3449                     }
   3450                     catch (NoViableAltException nvae) {
   3451                         dbg.recognitionException(nvae);
   3452                         throw nvae;
   3453                     }
   3454                     } finally {dbg.exitDecision(42);}
   3455 
   3456                     switch (alt42) {
   3457                         case 1 :
   3458                             dbg.enterAlt(1);
   3459 
   3460                             // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation
   3461                             {
   3462                             dbg.location(521,10);
   3463                             pushFollow(FOLLOW_explicitConstructorInvocation_in_methodDeclaration1778);
   3464                             explicitConstructorInvocation();
   3465 
   3466                             state._fsp--;
   3467                             if (state.failed) return ;
   3468 
   3469                             }
   3470                             break;
   3471 
   3472                     }
   3473                     } finally {dbg.exitSubRule(42);}
   3474 
   3475                     dbg.location(523,9);
   3476                     // src/com/google/doclava/parser/Java.g:523:9: ( blockStatement )*
   3477                     try { dbg.enterSubRule(43);
   3478 
   3479                     loop43:
   3480                     do {
   3481                         int alt43=2;
   3482                         try { dbg.enterDecision(43, decisionCanBacktrack[43]);
   3483 
   3484                         int LA43_0 = input.LA(1);
   3485 
   3486                         if ( ((LA43_0>=IDENTIFIER && LA43_0<=NULL)||(LA43_0>=ABSTRACT && LA43_0<=BYTE)||(LA43_0>=CHAR && LA43_0<=CLASS)||LA43_0==CONTINUE||(LA43_0>=DO && LA43_0<=DOUBLE)||LA43_0==ENUM||LA43_0==FINAL||(LA43_0>=FLOAT && LA43_0<=FOR)||LA43_0==IF||(LA43_0>=INT && LA43_0<=NEW)||(LA43_0>=PRIVATE && LA43_0<=THROW)||(LA43_0>=TRANSIENT && LA43_0<=LPAREN)||LA43_0==LBRACE||LA43_0==SEMI||(LA43_0>=BANG && LA43_0<=TILDE)||(LA43_0>=PLUSPLUS && LA43_0<=SUB)||LA43_0==MONKEYS_AT||LA43_0==LT) ) {
   3487                             alt43=1;
   3488                         }
   3489 
   3490 
   3491                         } finally {dbg.exitDecision(43);}
   3492 
   3493                         switch (alt43) {
   3494 			case 1 :
   3495 			    dbg.enterAlt(1);
   3496 
   3497 			    // src/com/google/doclava/parser/Java.g:523:10: blockStatement
   3498 			    {
   3499 			    dbg.location(523,10);
   3500 			    pushFollow(FOLLOW_blockStatement_in_methodDeclaration1800);
   3501 			    blockStatement();
   3502 
   3503 			    state._fsp--;
   3504 			    if (state.failed) return ;
   3505 
   3506 			    }
   3507 			    break;
   3508 
   3509 			default :
   3510 			    break loop43;
   3511                         }
   3512                     } while (true);
   3513                     } finally {dbg.exitSubRule(43);}
   3514 
   3515                     dbg.location(525,9);
   3516                     match(input,RBRACE,FOLLOW_RBRACE_in_methodDeclaration1821); if (state.failed) return ;
   3517 
   3518                     }
   3519                     break;
   3520                 case 2 :
   3521                     dbg.enterAlt(2);
   3522 
   3523                     // src/com/google/doclava/parser/Java.g:526:9: modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' )
   3524                     {
   3525                     dbg.location(526,9);
   3526                     pushFollow(FOLLOW_modifiers_in_methodDeclaration1831);
   3527                     modifiers();
   3528 
   3529                     state._fsp--;
   3530                     if (state.failed) return ;
   3531                     dbg.location(527,9);
   3532                     // src/com/google/doclava/parser/Java.g:527:9: ( typeParameters )?
   3533                     int alt44=2;
   3534                     try { dbg.enterSubRule(44);
   3535                     try { dbg.enterDecision(44, decisionCanBacktrack[44]);
   3536 
   3537                     int LA44_0 = input.LA(1);
   3538 
   3539                     if ( (LA44_0==LT) ) {
   3540                         alt44=1;
   3541                     }
   3542                     } finally {dbg.exitDecision(44);}
   3543 
   3544                     switch (alt44) {
   3545                         case 1 :
   3546                             dbg.enterAlt(1);
   3547 
   3548                             // src/com/google/doclava/parser/Java.g:527:10: typeParameters
   3549                             {
   3550                             dbg.location(527,10);
   3551                             pushFollow(FOLLOW_typeParameters_in_methodDeclaration1842);
   3552                             typeParameters();
   3553 
   3554                             state._fsp--;
   3555                             if (state.failed) return ;
   3556 
   3557                             }
   3558                             break;
   3559 
   3560                     }
   3561                     } finally {dbg.exitSubRule(44);}
   3562 
   3563                     dbg.location(529,9);
   3564                     // src/com/google/doclava/parser/Java.g:529:9: ( type | 'void' )
   3565                     int alt45=2;
   3566                     try { dbg.enterSubRule(45);
   3567                     try { dbg.enterDecision(45, decisionCanBacktrack[45]);
   3568 
   3569                     int LA45_0 = input.LA(1);
   3570 
   3571                     if ( (LA45_0==IDENTIFIER||LA45_0==BOOLEAN||LA45_0==BYTE||LA45_0==CHAR||LA45_0==DOUBLE||LA45_0==FLOAT||LA45_0==INT||LA45_0==LONG||LA45_0==SHORT) ) {
   3572                         alt45=1;
   3573                     }
   3574                     else if ( (LA45_0==VOID) ) {
   3575                         alt45=2;
   3576                     }
   3577                     else {
   3578                         if (state.backtracking>0) {state.failed=true; return ;}
   3579                         NoViableAltException nvae =
   3580                             new NoViableAltException("", 45, 0, input);
   3581 
   3582                         dbg.recognitionException(nvae);
   3583                         throw nvae;
   3584                     }
   3585                     } finally {dbg.exitDecision(45);}
   3586 
   3587                     switch (alt45) {
   3588                         case 1 :
   3589                             dbg.enterAlt(1);
   3590 
   3591                             // src/com/google/doclava/parser/Java.g:529:10: type
   3592                             {
   3593                             dbg.location(529,10);
   3594                             pushFollow(FOLLOW_type_in_methodDeclaration1864);
   3595                             type();
   3596 
   3597                             state._fsp--;
   3598                             if (state.failed) return ;
   3599 
   3600                             }
   3601                             break;
   3602                         case 2 :
   3603                             dbg.enterAlt(2);
   3604 
   3605                             // src/com/google/doclava/parser/Java.g:530:13: 'void'
   3606                             {
   3607                             dbg.location(530,13);
   3608                             match(input,VOID,FOLLOW_VOID_in_methodDeclaration1878); if (state.failed) return ;
   3609 
   3610                             }
   3611                             break;
   3612 
   3613                     }
   3614                     } finally {dbg.exitSubRule(45);}
   3615 
   3616                     dbg.location(532,9);
   3617                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration1898); if (state.failed) return ;
   3618                     dbg.location(533,9);
   3619                     pushFollow(FOLLOW_formalParameters_in_methodDeclaration1908);
   3620                     formalParameters();
   3621 
   3622                     state._fsp--;
   3623                     if (state.failed) return ;
   3624                     dbg.location(534,9);
   3625                     // src/com/google/doclava/parser/Java.g:534:9: ( '[' ']' )*
   3626                     try { dbg.enterSubRule(46);
   3627 
   3628                     loop46:
   3629                     do {
   3630                         int alt46=2;
   3631                         try { dbg.enterDecision(46, decisionCanBacktrack[46]);
   3632 
   3633                         int LA46_0 = input.LA(1);
   3634 
   3635                         if ( (LA46_0==LBRACKET) ) {
   3636                             alt46=1;
   3637                         }
   3638 
   3639 
   3640                         } finally {dbg.exitDecision(46);}
   3641 
   3642                         switch (alt46) {
   3643 			case 1 :
   3644 			    dbg.enterAlt(1);
   3645 
   3646 			    // src/com/google/doclava/parser/Java.g:534:10: '[' ']'
   3647 			    {
   3648 			    dbg.location(534,10);
   3649 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_methodDeclaration1919); if (state.failed) return ;
   3650 			    dbg.location(534,14);
   3651 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_methodDeclaration1921); if (state.failed) return ;
   3652 
   3653 			    }
   3654 			    break;
   3655 
   3656 			default :
   3657 			    break loop46;
   3658                         }
   3659                     } while (true);
   3660                     } finally {dbg.exitSubRule(46);}
   3661 
   3662                     dbg.location(536,9);
   3663                     // src/com/google/doclava/parser/Java.g:536:9: ( 'throws' qualifiedNameList )?
   3664                     int alt47=2;
   3665                     try { dbg.enterSubRule(47);
   3666                     try { dbg.enterDecision(47, decisionCanBacktrack[47]);
   3667 
   3668                     int LA47_0 = input.LA(1);
   3669 
   3670                     if ( (LA47_0==THROWS) ) {
   3671                         alt47=1;
   3672                     }
   3673                     } finally {dbg.exitDecision(47);}
   3674 
   3675                     switch (alt47) {
   3676                         case 1 :
   3677                             dbg.enterAlt(1);
   3678 
   3679                             // src/com/google/doclava/parser/Java.g:536:10: 'throws' qualifiedNameList
   3680                             {
   3681                             dbg.location(536,10);
   3682                             match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration1943); if (state.failed) return ;
   3683                             dbg.location(536,19);
   3684                             pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration1945);
   3685                             qualifiedNameList();
   3686 
   3687                             state._fsp--;
   3688                             if (state.failed) return ;
   3689 
   3690                             }
   3691                             break;
   3692 
   3693                     }
   3694                     } finally {dbg.exitSubRule(47);}
   3695 
   3696                     dbg.location(538,9);
   3697                     // src/com/google/doclava/parser/Java.g:538:9: ( block | ';' )
   3698                     int alt48=2;
   3699                     try { dbg.enterSubRule(48);
   3700                     try { dbg.enterDecision(48, decisionCanBacktrack[48]);
   3701 
   3702                     int LA48_0 = input.LA(1);
   3703 
   3704                     if ( (LA48_0==LBRACE) ) {
   3705                         alt48=1;
   3706                     }
   3707                     else if ( (LA48_0==SEMI) ) {
   3708                         alt48=2;
   3709                     }
   3710                     else {
   3711                         if (state.backtracking>0) {state.failed=true; return ;}
   3712                         NoViableAltException nvae =
   3713                             new NoViableAltException("", 48, 0, input);
   3714 
   3715                         dbg.recognitionException(nvae);
   3716                         throw nvae;
   3717                     }
   3718                     } finally {dbg.exitDecision(48);}
   3719 
   3720                     switch (alt48) {
   3721                         case 1 :
   3722                             dbg.enterAlt(1);
   3723 
   3724                             // src/com/google/doclava/parser/Java.g:539:13: block
   3725                             {
   3726                             dbg.location(539,13);
   3727                             pushFollow(FOLLOW_block_in_methodDeclaration1980);
   3728                             block();
   3729 
   3730                             state._fsp--;
   3731                             if (state.failed) return ;
   3732 
   3733                             }
   3734                             break;
   3735                         case 2 :
   3736                             dbg.enterAlt(2);
   3737 
   3738                             // src/com/google/doclava/parser/Java.g:540:13: ';'
   3739                             {
   3740                             dbg.location(540,13);
   3741                             match(input,SEMI,FOLLOW_SEMI_in_methodDeclaration1994); if (state.failed) return ;
   3742 
   3743                             }
   3744                             break;
   3745 
   3746                     }
   3747                     } finally {dbg.exitSubRule(48);}
   3748 
   3749 
   3750                     }
   3751                     break;
   3752 
   3753             }
   3754         }
   3755         catch (RecognitionException re) {
   3756             reportError(re);
   3757             recover(input,re);
   3758         }
   3759         finally {
   3760             if ( state.backtracking>0 ) { memoize(input, 26, methodDeclaration_StartIndex); }
   3761         }
   3762         dbg.location(542, 5);
   3763 
   3764         }
   3765         finally {
   3766             dbg.exitRule(getGrammarFileName(), "methodDeclaration");
   3767             decRuleLevel();
   3768             if ( getRuleLevel()==0 ) {dbg.terminate();}
   3769         }
   3770 
   3771         return ;
   3772     }
   3773     // $ANTLR end "methodDeclaration"
   3774 
   3775 
   3776     // $ANTLR start "fieldDeclaration"
   3777     // src/com/google/doclava/parser/Java.g:545:1: fieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ;
   3778     public final void fieldDeclaration() throws RecognitionException {
   3779         int fieldDeclaration_StartIndex = input.index();
   3780         try { dbg.enterRule(getGrammarFileName(), "fieldDeclaration");
   3781         if ( getRuleLevel()==0 ) {dbg.commence();}
   3782         incRuleLevel();
   3783         dbg.location(545, 1);
   3784 
   3785         try {
   3786             if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return ; }
   3787             // src/com/google/doclava/parser/Java.g:546:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' )
   3788             dbg.enterAlt(1);
   3789 
   3790             // src/com/google/doclava/parser/Java.g:546:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';'
   3791             {
   3792             dbg.location(546,9);
   3793             pushFollow(FOLLOW_modifiers_in_fieldDeclaration2024);
   3794             modifiers();
   3795 
   3796             state._fsp--;
   3797             if (state.failed) return ;
   3798             dbg.location(547,9);
   3799             pushFollow(FOLLOW_type_in_fieldDeclaration2034);
   3800             type();
   3801 
   3802             state._fsp--;
   3803             if (state.failed) return ;
   3804             dbg.location(548,9);
   3805             pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2044);
   3806             variableDeclarator();
   3807 
   3808             state._fsp--;
   3809             if (state.failed) return ;
   3810             dbg.location(549,9);
   3811             // src/com/google/doclava/parser/Java.g:549:9: ( ',' variableDeclarator )*
   3812             try { dbg.enterSubRule(50);
   3813 
   3814             loop50:
   3815             do {
   3816                 int alt50=2;
   3817                 try { dbg.enterDecision(50, decisionCanBacktrack[50]);
   3818 
   3819                 int LA50_0 = input.LA(1);
   3820 
   3821                 if ( (LA50_0==COMMA) ) {
   3822                     alt50=1;
   3823                 }
   3824 
   3825 
   3826                 } finally {dbg.exitDecision(50);}
   3827 
   3828                 switch (alt50) {
   3829 		case 1 :
   3830 		    dbg.enterAlt(1);
   3831 
   3832 		    // src/com/google/doclava/parser/Java.g:549:10: ',' variableDeclarator
   3833 		    {
   3834 		    dbg.location(549,10);
   3835 		    match(input,COMMA,FOLLOW_COMMA_in_fieldDeclaration2055); if (state.failed) return ;
   3836 		    dbg.location(549,14);
   3837 		    pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2057);
   3838 		    variableDeclarator();
   3839 
   3840 		    state._fsp--;
   3841 		    if (state.failed) return ;
   3842 
   3843 		    }
   3844 		    break;
   3845 
   3846 		default :
   3847 		    break loop50;
   3848                 }
   3849             } while (true);
   3850             } finally {dbg.exitSubRule(50);}
   3851 
   3852             dbg.location(551,9);
   3853             match(input,SEMI,FOLLOW_SEMI_in_fieldDeclaration2078); if (state.failed) return ;
   3854 
   3855             }
   3856 
   3857         }
   3858         catch (RecognitionException re) {
   3859             reportError(re);
   3860             recover(input,re);
   3861         }
   3862         finally {
   3863             if ( state.backtracking>0 ) { memoize(input, 27, fieldDeclaration_StartIndex); }
   3864         }
   3865         dbg.location(552, 5);
   3866 
   3867         }
   3868         finally {
   3869             dbg.exitRule(getGrammarFileName(), "fieldDeclaration");
   3870             decRuleLevel();
   3871             if ( getRuleLevel()==0 ) {dbg.terminate();}
   3872         }
   3873 
   3874         return ;
   3875     }
   3876     // $ANTLR end "fieldDeclaration"
   3877 
   3878 
   3879     // $ANTLR start "variableDeclarator"
   3880     // src/com/google/doclava/parser/Java.g:554:1: variableDeclarator : IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? ;
   3881     public final void variableDeclarator() throws RecognitionException {
   3882         int variableDeclarator_StartIndex = input.index();
   3883         try { dbg.enterRule(getGrammarFileName(), "variableDeclarator");
   3884         if ( getRuleLevel()==0 ) {dbg.commence();}
   3885         incRuleLevel();
   3886         dbg.location(554, 1);
   3887 
   3888         try {
   3889             if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return ; }
   3890             // src/com/google/doclava/parser/Java.g:555:5: ( IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? )
   3891             dbg.enterAlt(1);
   3892 
   3893             // src/com/google/doclava/parser/Java.g:555:9: IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )?
   3894             {
   3895             dbg.location(555,9);
   3896             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variableDeclarator2097); if (state.failed) return ;
   3897             dbg.location(556,9);
   3898             // src/com/google/doclava/parser/Java.g:556:9: ( '[' ']' )*
   3899             try { dbg.enterSubRule(51);
   3900 
   3901             loop51:
   3902             do {
   3903                 int alt51=2;
   3904                 try { dbg.enterDecision(51, decisionCanBacktrack[51]);
   3905 
   3906                 int LA51_0 = input.LA(1);
   3907 
   3908                 if ( (LA51_0==LBRACKET) ) {
   3909                     alt51=1;
   3910                 }
   3911 
   3912 
   3913                 } finally {dbg.exitDecision(51);}
   3914 
   3915                 switch (alt51) {
   3916 		case 1 :
   3917 		    dbg.enterAlt(1);
   3918 
   3919 		    // src/com/google/doclava/parser/Java.g:556:10: '[' ']'
   3920 		    {
   3921 		    dbg.location(556,10);
   3922 		    match(input,LBRACKET,FOLLOW_LBRACKET_in_variableDeclarator2108); if (state.failed) return ;
   3923 		    dbg.location(556,14);
   3924 		    match(input,RBRACKET,FOLLOW_RBRACKET_in_variableDeclarator2110); if (state.failed) return ;
   3925 
   3926 		    }
   3927 		    break;
   3928 
   3929 		default :
   3930 		    break loop51;
   3931                 }
   3932             } while (true);
   3933             } finally {dbg.exitSubRule(51);}
   3934 
   3935             dbg.location(558,9);
   3936             // src/com/google/doclava/parser/Java.g:558:9: ( '=' variableInitializer )?
   3937             int alt52=2;
   3938             try { dbg.enterSubRule(52);
   3939             try { dbg.enterDecision(52, decisionCanBacktrack[52]);
   3940 
   3941             int LA52_0 = input.LA(1);
   3942 
   3943             if ( (LA52_0==EQ) ) {
   3944                 alt52=1;
   3945             }
   3946             } finally {dbg.exitDecision(52);}
   3947 
   3948             switch (alt52) {
   3949                 case 1 :
   3950                     dbg.enterAlt(1);
   3951 
   3952                     // src/com/google/doclava/parser/Java.g:558:10: '=' variableInitializer
   3953                     {
   3954                     dbg.location(558,10);
   3955                     match(input,EQ,FOLLOW_EQ_in_variableDeclarator2132); if (state.failed) return ;
   3956                     dbg.location(558,14);
   3957                     pushFollow(FOLLOW_variableInitializer_in_variableDeclarator2134);
   3958                     variableInitializer();
   3959 
   3960                     state._fsp--;
   3961                     if (state.failed) return ;
   3962 
   3963                     }
   3964                     break;
   3965 
   3966             }
   3967             } finally {dbg.exitSubRule(52);}
   3968 
   3969 
   3970             }
   3971 
   3972         }
   3973         catch (RecognitionException re) {
   3974             reportError(re);
   3975             recover(input,re);
   3976         }
   3977         finally {
   3978             if ( state.backtracking>0 ) { memoize(input, 28, variableDeclarator_StartIndex); }
   3979         }
   3980         dbg.location(560, 5);
   3981 
   3982         }
   3983         finally {
   3984             dbg.exitRule(getGrammarFileName(), "variableDeclarator");
   3985             decRuleLevel();
   3986             if ( getRuleLevel()==0 ) {dbg.terminate();}
   3987         }
   3988 
   3989         return ;
   3990     }
   3991     // $ANTLR end "variableDeclarator"
   3992 
   3993 
   3994     // $ANTLR start "interfaceBodyDeclaration"
   3995     // src/com/google/doclava/parser/Java.g:562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' );
   3996     public final void interfaceBodyDeclaration() throws RecognitionException {
   3997         int interfaceBodyDeclaration_StartIndex = input.index();
   3998         try { dbg.enterRule(getGrammarFileName(), "interfaceBodyDeclaration");
   3999         if ( getRuleLevel()==0 ) {dbg.commence();}
   4000         incRuleLevel();
   4001         dbg.location(562, 1);
   4002 
   4003         try {
   4004             if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return ; }
   4005             // src/com/google/doclava/parser/Java.g:566:5: ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' )
   4006             int alt53=5;
   4007             try { dbg.enterDecision(53, decisionCanBacktrack[53]);
   4008 
   4009             try {
   4010                 isCyclicDecision = true;
   4011                 alt53 = dfa53.predict(input);
   4012             }
   4013             catch (NoViableAltException nvae) {
   4014                 dbg.recognitionException(nvae);
   4015                 throw nvae;
   4016             }
   4017             } finally {dbg.exitDecision(53);}
   4018 
   4019             switch (alt53) {
   4020                 case 1 :
   4021                     dbg.enterAlt(1);
   4022 
   4023                     // src/com/google/doclava/parser/Java.g:567:9: interfaceFieldDeclaration
   4024                     {
   4025                     dbg.location(567,9);
   4026                     pushFollow(FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2172);
   4027                     interfaceFieldDeclaration();
   4028 
   4029                     state._fsp--;
   4030                     if (state.failed) return ;
   4031 
   4032                     }
   4033                     break;
   4034                 case 2 :
   4035                     dbg.enterAlt(2);
   4036 
   4037                     // src/com/google/doclava/parser/Java.g:568:9: interfaceMethodDeclaration
   4038                     {
   4039                     dbg.location(568,9);
   4040                     pushFollow(FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2182);
   4041                     interfaceMethodDeclaration();
   4042 
   4043                     state._fsp--;
   4044                     if (state.failed) return ;
   4045 
   4046                     }
   4047                     break;
   4048                 case 3 :
   4049                     dbg.enterAlt(3);
   4050 
   4051                     // src/com/google/doclava/parser/Java.g:569:9: interfaceDeclaration
   4052                     {
   4053                     dbg.location(569,9);
   4054                     pushFollow(FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2192);
   4055                     interfaceDeclaration();
   4056 
   4057                     state._fsp--;
   4058                     if (state.failed) return ;
   4059 
   4060                     }
   4061                     break;
   4062                 case 4 :
   4063                     dbg.enterAlt(4);
   4064 
   4065                     // src/com/google/doclava/parser/Java.g:570:9: classDeclaration
   4066                     {
   4067                     dbg.location(570,9);
   4068                     pushFollow(FOLLOW_classDeclaration_in_interfaceBodyDeclaration2202);
   4069                     classDeclaration();
   4070 
   4071                     state._fsp--;
   4072                     if (state.failed) return ;
   4073 
   4074                     }
   4075                     break;
   4076                 case 5 :
   4077                     dbg.enterAlt(5);
   4078 
   4079                     // src/com/google/doclava/parser/Java.g:571:9: ';'
   4080                     {
   4081                     dbg.location(571,9);
   4082                     match(input,SEMI,FOLLOW_SEMI_in_interfaceBodyDeclaration2212); if (state.failed) return ;
   4083 
   4084                     }
   4085                     break;
   4086 
   4087             }
   4088         }
   4089         catch (RecognitionException re) {
   4090             reportError(re);
   4091             recover(input,re);
   4092         }
   4093         finally {
   4094             if ( state.backtracking>0 ) { memoize(input, 29, interfaceBodyDeclaration_StartIndex); }
   4095         }
   4096         dbg.location(572, 5);
   4097 
   4098         }
   4099         finally {
   4100             dbg.exitRule(getGrammarFileName(), "interfaceBodyDeclaration");
   4101             decRuleLevel();
   4102             if ( getRuleLevel()==0 ) {dbg.terminate();}
   4103         }
   4104 
   4105         return ;
   4106     }
   4107     // $ANTLR end "interfaceBodyDeclaration"
   4108 
   4109 
   4110     // $ANTLR start "interfaceMethodDeclaration"
   4111     // src/com/google/doclava/parser/Java.g:574:1: interfaceMethodDeclaration : modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' ;
   4112     public final void interfaceMethodDeclaration() throws RecognitionException {
   4113         int interfaceMethodDeclaration_StartIndex = input.index();
   4114         try { dbg.enterRule(getGrammarFileName(), "interfaceMethodDeclaration");
   4115         if ( getRuleLevel()==0 ) {dbg.commence();}
   4116         incRuleLevel();
   4117         dbg.location(574, 1);
   4118 
   4119         try {
   4120             if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return ; }
   4121             // src/com/google/doclava/parser/Java.g:575:5: ( modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' )
   4122             dbg.enterAlt(1);
   4123 
   4124             // src/com/google/doclava/parser/Java.g:575:9: modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';'
   4125             {
   4126             dbg.location(575,9);
   4127             pushFollow(FOLLOW_modifiers_in_interfaceMethodDeclaration2231);
   4128             modifiers();
   4129 
   4130             state._fsp--;
   4131             if (state.failed) return ;
   4132             dbg.location(576,9);
   4133             // src/com/google/doclava/parser/Java.g:576:9: ( typeParameters )?
   4134             int alt54=2;
   4135             try { dbg.enterSubRule(54);
   4136             try { dbg.enterDecision(54, decisionCanBacktrack[54]);
   4137 
   4138             int LA54_0 = input.LA(1);
   4139 
   4140             if ( (LA54_0==LT) ) {
   4141                 alt54=1;
   4142             }
   4143             } finally {dbg.exitDecision(54);}
   4144 
   4145             switch (alt54) {
   4146                 case 1 :
   4147                     dbg.enterAlt(1);
   4148 
   4149                     // src/com/google/doclava/parser/Java.g:576:10: typeParameters
   4150                     {
   4151                     dbg.location(576,10);
   4152                     pushFollow(FOLLOW_typeParameters_in_interfaceMethodDeclaration2242);
   4153                     typeParameters();
   4154 
   4155                     state._fsp--;
   4156                     if (state.failed) return ;
   4157 
   4158                     }
   4159                     break;
   4160 
   4161             }
   4162             } finally {dbg.exitSubRule(54);}
   4163 
   4164             dbg.location(578,9);
   4165             // src/com/google/doclava/parser/Java.g:578:9: ( type | 'void' )
   4166             int alt55=2;
   4167             try { dbg.enterSubRule(55);
   4168             try { dbg.enterDecision(55, decisionCanBacktrack[55]);
   4169 
   4170             int LA55_0 = input.LA(1);
   4171 
   4172             if ( (LA55_0==IDENTIFIER||LA55_0==BOOLEAN||LA55_0==BYTE||LA55_0==CHAR||LA55_0==DOUBLE||LA55_0==FLOAT||LA55_0==INT||LA55_0==LONG||LA55_0==SHORT) ) {
   4173                 alt55=1;
   4174             }
   4175             else if ( (LA55_0==VOID) ) {
   4176                 alt55=2;
   4177             }
   4178             else {
   4179                 if (state.backtracking>0) {state.failed=true; return ;}
   4180                 NoViableAltException nvae =
   4181                     new NoViableAltException("", 55, 0, input);
   4182 
   4183                 dbg.recognitionException(nvae);
   4184                 throw nvae;
   4185             }
   4186             } finally {dbg.exitDecision(55);}
   4187 
   4188             switch (alt55) {
   4189                 case 1 :
   4190                     dbg.enterAlt(1);
   4191 
   4192                     // src/com/google/doclava/parser/Java.g:578:10: type
   4193                     {
   4194                     dbg.location(578,10);
   4195                     pushFollow(FOLLOW_type_in_interfaceMethodDeclaration2264);
   4196                     type();
   4197 
   4198                     state._fsp--;
   4199                     if (state.failed) return ;
   4200 
   4201                     }
   4202                     break;
   4203                 case 2 :
   4204                     dbg.enterAlt(2);
   4205 
   4206                     // src/com/google/doclava/parser/Java.g:579:10: 'void'
   4207                     {
   4208                     dbg.location(579,10);
   4209                     match(input,VOID,FOLLOW_VOID_in_interfaceMethodDeclaration2275); if (state.failed) return ;
   4210 
   4211                     }
   4212                     break;
   4213 
   4214             }
   4215             } finally {dbg.exitSubRule(55);}
   4216 
   4217             dbg.location(581,9);
   4218             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2295); if (state.failed) return ;
   4219             dbg.location(582,9);
   4220             pushFollow(FOLLOW_formalParameters_in_interfaceMethodDeclaration2305);
   4221             formalParameters();
   4222 
   4223             state._fsp--;
   4224             if (state.failed) return ;
   4225             dbg.location(583,9);
   4226             // src/com/google/doclava/parser/Java.g:583:9: ( '[' ']' )*
   4227             try { dbg.enterSubRule(56);
   4228 
   4229             loop56:
   4230             do {
   4231                 int alt56=2;
   4232                 try { dbg.enterDecision(56, decisionCanBacktrack[56]);
   4233 
   4234                 int LA56_0 = input.LA(1);
   4235 
   4236                 if ( (LA56_0==LBRACKET) ) {
   4237                     alt56=1;
   4238                 }
   4239 
   4240 
   4241                 } finally {dbg.exitDecision(56);}
   4242 
   4243                 switch (alt56) {
   4244 		case 1 :
   4245 		    dbg.enterAlt(1);
   4246 
   4247 		    // src/com/google/doclava/parser/Java.g:583:10: '[' ']'
   4248 		    {
   4249 		    dbg.location(583,10);
   4250 		    match(input,LBRACKET,FOLLOW_LBRACKET_in_interfaceMethodDeclaration2316); if (state.failed) return ;
   4251 		    dbg.location(583,14);
   4252 		    match(input,RBRACKET,FOLLOW_RBRACKET_in_interfaceMethodDeclaration2318); if (state.failed) return ;
   4253 
   4254 		    }
   4255 		    break;
   4256 
   4257 		default :
   4258 		    break loop56;
   4259                 }
   4260             } while (true);
   4261             } finally {dbg.exitSubRule(56);}
   4262 
   4263             dbg.location(585,9);
   4264             // src/com/google/doclava/parser/Java.g:585:9: ( 'throws' qualifiedNameList )?
   4265             int alt57=2;
   4266             try { dbg.enterSubRule(57);
   4267             try { dbg.enterDecision(57, decisionCanBacktrack[57]);
   4268 
   4269             int LA57_0 = input.LA(1);
   4270 
   4271             if ( (LA57_0==THROWS) ) {
   4272                 alt57=1;
   4273             }
   4274             } finally {dbg.exitDecision(57);}
   4275 
   4276             switch (alt57) {
   4277                 case 1 :
   4278                     dbg.enterAlt(1);
   4279 
   4280                     // src/com/google/doclava/parser/Java.g:585:10: 'throws' qualifiedNameList
   4281                     {
   4282                     dbg.location(585,10);
   4283                     match(input,THROWS,FOLLOW_THROWS_in_interfaceMethodDeclaration2340); if (state.failed) return ;
   4284                     dbg.location(585,19);
   4285                     pushFollow(FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2342);
   4286                     qualifiedNameList();
   4287 
   4288                     state._fsp--;
   4289                     if (state.failed) return ;
   4290 
   4291                     }
   4292                     break;
   4293 
   4294             }
   4295             } finally {dbg.exitSubRule(57);}
   4296 
   4297             dbg.location(586,12);
   4298             match(input,SEMI,FOLLOW_SEMI_in_interfaceMethodDeclaration2355); if (state.failed) return ;
   4299 
   4300             }
   4301 
   4302         }
   4303         catch (RecognitionException re) {
   4304             reportError(re);
   4305             recover(input,re);
   4306         }
   4307         finally {
   4308             if ( state.backtracking>0 ) { memoize(input, 30, interfaceMethodDeclaration_StartIndex); }
   4309         }
   4310         dbg.location(587, 5);
   4311 
   4312         }
   4313         finally {
   4314             dbg.exitRule(getGrammarFileName(), "interfaceMethodDeclaration");
   4315             decRuleLevel();
   4316             if ( getRuleLevel()==0 ) {dbg.terminate();}
   4317         }
   4318 
   4319         return ;
   4320     }
   4321     // $ANTLR end "interfaceMethodDeclaration"
   4322 
   4323 
   4324     // $ANTLR start "interfaceFieldDeclaration"
   4325     // src/com/google/doclava/parser/Java.g:589:1: interfaceFieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ;
   4326     public final void interfaceFieldDeclaration() throws RecognitionException {
   4327         int interfaceFieldDeclaration_StartIndex = input.index();
   4328         try { dbg.enterRule(getGrammarFileName(), "interfaceFieldDeclaration");
   4329         if ( getRuleLevel()==0 ) {dbg.commence();}
   4330         incRuleLevel();
   4331         dbg.location(589, 1);
   4332 
   4333         try {
   4334             if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return ; }
   4335             // src/com/google/doclava/parser/Java.g:595:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' )
   4336             dbg.enterAlt(1);
   4337 
   4338             // src/com/google/doclava/parser/Java.g:595:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';'
   4339             {
   4340             dbg.location(595,9);
   4341             pushFollow(FOLLOW_modifiers_in_interfaceFieldDeclaration2376);
   4342             modifiers();
   4343 
   4344             state._fsp--;
   4345             if (state.failed) return ;
   4346             dbg.location(595,19);
   4347             pushFollow(FOLLOW_type_in_interfaceFieldDeclaration2378);
   4348             type();
   4349 
   4350             state._fsp--;
   4351             if (state.failed) return ;
   4352             dbg.location(595,24);
   4353             pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2380);
   4354             variableDeclarator();
   4355 
   4356             state._fsp--;
   4357             if (state.failed) return ;
   4358             dbg.location(596,9);
   4359             // src/com/google/doclava/parser/Java.g:596:9: ( ',' variableDeclarator )*
   4360             try { dbg.enterSubRule(58);
   4361 
   4362             loop58:
   4363             do {
   4364                 int alt58=2;
   4365                 try { dbg.enterDecision(58, decisionCanBacktrack[58]);
   4366 
   4367                 int LA58_0 = input.LA(1);
   4368 
   4369                 if ( (LA58_0==COMMA) ) {
   4370                     alt58=1;
   4371                 }
   4372 
   4373 
   4374                 } finally {dbg.exitDecision(58);}
   4375 
   4376                 switch (alt58) {
   4377 		case 1 :
   4378 		    dbg.enterAlt(1);
   4379 
   4380 		    // src/com/google/doclava/parser/Java.g:596:10: ',' variableDeclarator
   4381 		    {
   4382 		    dbg.location(596,10);
   4383 		    match(input,COMMA,FOLLOW_COMMA_in_interfaceFieldDeclaration2391); if (state.failed) return ;
   4384 		    dbg.location(596,14);
   4385 		    pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2393);
   4386 		    variableDeclarator();
   4387 
   4388 		    state._fsp--;
   4389 		    if (state.failed) return ;
   4390 
   4391 		    }
   4392 		    break;
   4393 
   4394 		default :
   4395 		    break loop58;
   4396                 }
   4397             } while (true);
   4398             } finally {dbg.exitSubRule(58);}
   4399 
   4400             dbg.location(598,9);
   4401             match(input,SEMI,FOLLOW_SEMI_in_interfaceFieldDeclaration2414); if (state.failed) return ;
   4402 
   4403             }
   4404 
   4405         }
   4406         catch (RecognitionException re) {
   4407             reportError(re);
   4408             recover(input,re);
   4409         }
   4410         finally {
   4411             if ( state.backtracking>0 ) { memoize(input, 31, interfaceFieldDeclaration_StartIndex); }
   4412         }
   4413         dbg.location(599, 5);
   4414 
   4415         }
   4416         finally {
   4417             dbg.exitRule(getGrammarFileName(), "interfaceFieldDeclaration");
   4418             decRuleLevel();
   4419             if ( getRuleLevel()==0 ) {dbg.terminate();}
   4420         }
   4421 
   4422         return ;
   4423     }
   4424     // $ANTLR end "interfaceFieldDeclaration"
   4425 
   4426 
   4427     // $ANTLR start "type"
   4428     // src/com/google/doclava/parser/Java.g:602:1: type : ( classOrInterfaceType ( '[' ']' )* | primitiveType ( '[' ']' )* );
   4429     public final void type() throws RecognitionException {
   4430         int type_StartIndex = input.index();
   4431         try { dbg.enterRule(getGrammarFileName(), "type");
   4432         if ( getRuleLevel()==0 ) {dbg.commence();}
   4433         incRuleLevel();
   4434         dbg.location(602, 1);
   4435 
   4436         try {
   4437             if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return ; }
   4438             // src/com/google/doclava/parser/Java.g:603:5: ( classOrInterfaceType ( '[' ']' )* | primitiveType ( '[' ']' )* )
   4439             int alt61=2;
   4440             try { dbg.enterDecision(61, decisionCanBacktrack[61]);
   4441 
   4442             int LA61_0 = input.LA(1);
   4443 
   4444             if ( (LA61_0==IDENTIFIER) ) {
   4445                 alt61=1;
   4446             }
   4447             else if ( (LA61_0==BOOLEAN||LA61_0==BYTE||LA61_0==CHAR||LA61_0==DOUBLE||LA61_0==FLOAT||LA61_0==INT||LA61_0==LONG||LA61_0==SHORT) ) {
   4448                 alt61=2;
   4449             }
   4450             else {
   4451                 if (state.backtracking>0) {state.failed=true; return ;}
   4452                 NoViableAltException nvae =
   4453                     new NoViableAltException("", 61, 0, input);
   4454 
   4455                 dbg.recognitionException(nvae);
   4456                 throw nvae;
   4457             }
   4458             } finally {dbg.exitDecision(61);}
   4459 
   4460             switch (alt61) {
   4461                 case 1 :
   4462                     dbg.enterAlt(1);
   4463 
   4464                     // src/com/google/doclava/parser/Java.g:603:9: classOrInterfaceType ( '[' ']' )*
   4465                     {
   4466                     dbg.location(603,9);
   4467                     pushFollow(FOLLOW_classOrInterfaceType_in_type2434);
   4468                     classOrInterfaceType();
   4469 
   4470                     state._fsp--;
   4471                     if (state.failed) return ;
   4472                     dbg.location(604,9);
   4473                     // src/com/google/doclava/parser/Java.g:604:9: ( '[' ']' )*
   4474                     try { dbg.enterSubRule(59);
   4475 
   4476                     loop59:
   4477                     do {
   4478                         int alt59=2;
   4479                         try { dbg.enterDecision(59, decisionCanBacktrack[59]);
   4480 
   4481                         int LA59_0 = input.LA(1);
   4482 
   4483                         if ( (LA59_0==LBRACKET) ) {
   4484                             alt59=1;
   4485                         }
   4486 
   4487 
   4488                         } finally {dbg.exitDecision(59);}
   4489 
   4490                         switch (alt59) {
   4491 			case 1 :
   4492 			    dbg.enterAlt(1);
   4493 
   4494 			    // src/com/google/doclava/parser/Java.g:604:10: '[' ']'
   4495 			    {
   4496 			    dbg.location(604,10);
   4497 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_type2445); if (state.failed) return ;
   4498 			    dbg.location(604,14);
   4499 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_type2447); if (state.failed) return ;
   4500 
   4501 			    }
   4502 			    break;
   4503 
   4504 			default :
   4505 			    break loop59;
   4506                         }
   4507                     } while (true);
   4508                     } finally {dbg.exitSubRule(59);}
   4509 
   4510 
   4511                     }
   4512                     break;
   4513                 case 2 :
   4514                     dbg.enterAlt(2);
   4515 
   4516                     // src/com/google/doclava/parser/Java.g:606:9: primitiveType ( '[' ']' )*
   4517                     {
   4518                     dbg.location(606,9);
   4519                     pushFollow(FOLLOW_primitiveType_in_type2468);
   4520                     primitiveType();
   4521 
   4522                     state._fsp--;
   4523                     if (state.failed) return ;
   4524                     dbg.location(607,9);
   4525                     // src/com/google/doclava/parser/Java.g:607:9: ( '[' ']' )*
   4526                     try { dbg.enterSubRule(60);
   4527 
   4528                     loop60:
   4529                     do {
   4530                         int alt60=2;
   4531                         try { dbg.enterDecision(60, decisionCanBacktrack[60]);
   4532 
   4533                         int LA60_0 = input.LA(1);
   4534 
   4535                         if ( (LA60_0==LBRACKET) ) {
   4536                             alt60=1;
   4537                         }
   4538 
   4539 
   4540                         } finally {dbg.exitDecision(60);}
   4541 
   4542                         switch (alt60) {
   4543 			case 1 :
   4544 			    dbg.enterAlt(1);
   4545 
   4546 			    // src/com/google/doclava/parser/Java.g:607:10: '[' ']'
   4547 			    {
   4548 			    dbg.location(607,10);
   4549 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_type2479); if (state.failed) return ;
   4550 			    dbg.location(607,14);
   4551 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_type2481); if (state.failed) return ;
   4552 
   4553 			    }
   4554 			    break;
   4555 
   4556 			default :
   4557 			    break loop60;
   4558                         }
   4559                     } while (true);
   4560                     } finally {dbg.exitSubRule(60);}
   4561 
   4562 
   4563                     }
   4564                     break;
   4565 
   4566             }
   4567         }
   4568         catch (RecognitionException re) {
   4569             reportError(re);
   4570             recover(input,re);
   4571         }
   4572         finally {
   4573             if ( state.backtracking>0 ) { memoize(input, 32, type_StartIndex); }
   4574         }
   4575         dbg.location(609, 5);
   4576 
   4577         }
   4578         finally {
   4579             dbg.exitRule(getGrammarFileName(), "type");
   4580             decRuleLevel();
   4581             if ( getRuleLevel()==0 ) {dbg.terminate();}
   4582         }
   4583 
   4584         return ;
   4585     }
   4586     // $ANTLR end "type"
   4587 
   4588 
   4589     // $ANTLR start "classOrInterfaceType"
   4590     // src/com/google/doclava/parser/Java.g:612:1: classOrInterfaceType : IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* ;
   4591     public final void classOrInterfaceType() throws RecognitionException {
   4592         int classOrInterfaceType_StartIndex = input.index();
   4593         try { dbg.enterRule(getGrammarFileName(), "classOrInterfaceType");
   4594         if ( getRuleLevel()==0 ) {dbg.commence();}
   4595         incRuleLevel();
   4596         dbg.location(612, 1);
   4597 
   4598         try {
   4599             if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return ; }
   4600             // src/com/google/doclava/parser/Java.g:613:5: ( IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* )
   4601             dbg.enterAlt(1);
   4602 
   4603             // src/com/google/doclava/parser/Java.g:613:9: IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )*
   4604             {
   4605             dbg.location(613,9);
   4606             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType2512); if (state.failed) return ;
   4607             dbg.location(614,9);
   4608             // src/com/google/doclava/parser/Java.g:614:9: ( typeArguments )?
   4609             int alt62=2;
   4610             try { dbg.enterSubRule(62);
   4611             try { dbg.enterDecision(62, decisionCanBacktrack[62]);
   4612 
   4613             int LA62_0 = input.LA(1);
   4614 
   4615             if ( (LA62_0==LT) ) {
   4616                 int LA62_1 = input.LA(2);
   4617 
   4618                 if ( (LA62_1==IDENTIFIER||LA62_1==BOOLEAN||LA62_1==BYTE||LA62_1==CHAR||LA62_1==DOUBLE||LA62_1==FLOAT||LA62_1==INT||LA62_1==LONG||LA62_1==SHORT||LA62_1==QUES) ) {
   4619                     alt62=1;
   4620                 }
   4621             }
   4622             } finally {dbg.exitDecision(62);}
   4623 
   4624             switch (alt62) {
   4625                 case 1 :
   4626                     dbg.enterAlt(1);
   4627 
   4628                     // src/com/google/doclava/parser/Java.g:614:10: typeArguments
   4629                     {
   4630                     dbg.location(614,10);
   4631                     pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType2523);
   4632                     typeArguments();
   4633 
   4634                     state._fsp--;
   4635                     if (state.failed) return ;
   4636 
   4637                     }
   4638                     break;
   4639 
   4640             }
   4641             } finally {dbg.exitSubRule(62);}
   4642 
   4643             dbg.location(616,9);
   4644             // src/com/google/doclava/parser/Java.g:616:9: ( '.' IDENTIFIER ( typeArguments )? )*
   4645             try { dbg.enterSubRule(64);
   4646 
   4647             loop64:
   4648             do {
   4649                 int alt64=2;
   4650                 try { dbg.enterDecision(64, decisionCanBacktrack[64]);
   4651 
   4652                 int LA64_0 = input.LA(1);
   4653 
   4654                 if ( (LA64_0==DOT) ) {
   4655                     alt64=1;
   4656                 }
   4657 
   4658 
   4659                 } finally {dbg.exitDecision(64);}
   4660 
   4661                 switch (alt64) {
   4662 		case 1 :
   4663 		    dbg.enterAlt(1);
   4664 
   4665 		    // src/com/google/doclava/parser/Java.g:616:10: '.' IDENTIFIER ( typeArguments )?
   4666 		    {
   4667 		    dbg.location(616,10);
   4668 		    match(input,DOT,FOLLOW_DOT_in_classOrInterfaceType2545); if (state.failed) return ;
   4669 		    dbg.location(616,14);
   4670 		    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType2547); if (state.failed) return ;
   4671 		    dbg.location(617,13);
   4672 		    // src/com/google/doclava/parser/Java.g:617:13: ( typeArguments )?
   4673 		    int alt63=2;
   4674 		    try { dbg.enterSubRule(63);
   4675 		    try { dbg.enterDecision(63, decisionCanBacktrack[63]);
   4676 
   4677 		    int LA63_0 = input.LA(1);
   4678 
   4679 		    if ( (LA63_0==LT) ) {
   4680 		        int LA63_1 = input.LA(2);
   4681 
   4682 		        if ( (LA63_1==IDENTIFIER||LA63_1==BOOLEAN||LA63_1==BYTE||LA63_1==CHAR||LA63_1==DOUBLE||LA63_1==FLOAT||LA63_1==INT||LA63_1==LONG||LA63_1==SHORT||LA63_1==QUES) ) {
   4683 		            alt63=1;
   4684 		        }
   4685 		    }
   4686 		    } finally {dbg.exitDecision(63);}
   4687 
   4688 		    switch (alt63) {
   4689 		        case 1 :
   4690 		            dbg.enterAlt(1);
   4691 
   4692 		            // src/com/google/doclava/parser/Java.g:617:14: typeArguments
   4693 		            {
   4694 		            dbg.location(617,14);
   4695 		            pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType2562);
   4696 		            typeArguments();
   4697 
   4698 		            state._fsp--;
   4699 		            if (state.failed) return ;
   4700 
   4701 		            }
   4702 		            break;
   4703 
   4704 		    }
   4705 		    } finally {dbg.exitSubRule(63);}
   4706 
   4707 
   4708 		    }
   4709 		    break;
   4710 
   4711 		default :
   4712 		    break loop64;
   4713                 }
   4714             } while (true);
   4715             } finally {dbg.exitSubRule(64);}
   4716 
   4717 
   4718             }
   4719 
   4720         }
   4721         catch (RecognitionException re) {
   4722             reportError(re);
   4723             recover(input,re);
   4724         }
   4725         finally {
   4726             if ( state.backtracking>0 ) { memoize(input, 33, classOrInterfaceType_StartIndex); }
   4727         }
   4728         dbg.location(620, 5);
   4729 
   4730         }
   4731         finally {
   4732             dbg.exitRule(getGrammarFileName(), "classOrInterfaceType");
   4733             decRuleLevel();
   4734             if ( getRuleLevel()==0 ) {dbg.terminate();}
   4735         }
   4736 
   4737         return ;
   4738     }
   4739     // $ANTLR end "classOrInterfaceType"
   4740 
   4741 
   4742     // $ANTLR start "primitiveType"
   4743     // src/com/google/doclava/parser/Java.g:622:1: primitiveType : ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' );
   4744     public final void primitiveType() throws RecognitionException {
   4745         int primitiveType_StartIndex = input.index();
   4746         try { dbg.enterRule(getGrammarFileName(), "primitiveType");
   4747         if ( getRuleLevel()==0 ) {dbg.commence();}
   4748         incRuleLevel();
   4749         dbg.location(622, 1);
   4750 
   4751         try {
   4752             if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return ; }
   4753             // src/com/google/doclava/parser/Java.g:623:5: ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' )
   4754             dbg.enterAlt(1);
   4755 
   4756             // src/com/google/doclava/parser/Java.g:
   4757             {
   4758             dbg.location(623,5);
   4759             if ( input.LA(1)==BOOLEAN||input.LA(1)==BYTE||input.LA(1)==CHAR||input.LA(1)==DOUBLE||input.LA(1)==FLOAT||input.LA(1)==INT||input.LA(1)==LONG||input.LA(1)==SHORT ) {
   4760                 input.consume();
   4761                 state.errorRecovery=false;state.failed=false;
   4762             }
   4763             else {
   4764                 if (state.backtracking>0) {state.failed=true; return ;}
   4765                 MismatchedSetException mse = new MismatchedSetException(null,input);
   4766                 dbg.recognitionException(mse);
   4767                 throw mse;
   4768             }
   4769 
   4770 
   4771             }
   4772 
   4773         }
   4774         catch (RecognitionException re) {
   4775             reportError(re);
   4776             recover(input,re);
   4777         }
   4778         finally {
   4779             if ( state.backtracking>0 ) { memoize(input, 34, primitiveType_StartIndex); }
   4780         }
   4781         dbg.location(631, 5);
   4782 
   4783         }
   4784         finally {
   4785             dbg.exitRule(getGrammarFileName(), "primitiveType");
   4786             decRuleLevel();
   4787             if ( getRuleLevel()==0 ) {dbg.terminate();}
   4788         }
   4789 
   4790         return ;
   4791     }
   4792     // $ANTLR end "primitiveType"
   4793 
   4794 
   4795     // $ANTLR start "typeArguments"
   4796     // src/com/google/doclava/parser/Java.g:633:1: typeArguments : '<' typeArgument ( ',' typeArgument )* '>' ;
   4797     public final void typeArguments() throws RecognitionException {
   4798         int typeArguments_StartIndex = input.index();
   4799         try { dbg.enterRule(getGrammarFileName(), "typeArguments");
   4800         if ( getRuleLevel()==0 ) {dbg.commence();}
   4801         incRuleLevel();
   4802         dbg.location(633, 1);
   4803 
   4804         try {
   4805             if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return ; }
   4806             // src/com/google/doclava/parser/Java.g:634:5: ( '<' typeArgument ( ',' typeArgument )* '>' )
   4807             dbg.enterAlt(1);
   4808 
   4809             // src/com/google/doclava/parser/Java.g:634:9: '<' typeArgument ( ',' typeArgument )* '>'
   4810             {
   4811             dbg.location(634,9);
   4812             match(input,LT,FOLLOW_LT_in_typeArguments2696); if (state.failed) return ;
   4813             dbg.location(634,13);
   4814             pushFollow(FOLLOW_typeArgument_in_typeArguments2698);
   4815             typeArgument();
   4816 
   4817             state._fsp--;
   4818             if (state.failed) return ;
   4819             dbg.location(635,9);
   4820             // src/com/google/doclava/parser/Java.g:635:9: ( ',' typeArgument )*
   4821             try { dbg.enterSubRule(65);
   4822 
   4823             loop65:
   4824             do {
   4825                 int alt65=2;
   4826                 try { dbg.enterDecision(65, decisionCanBacktrack[65]);
   4827 
   4828                 int LA65_0 = input.LA(1);
   4829 
   4830                 if ( (LA65_0==COMMA) ) {
   4831                     alt65=1;
   4832                 }
   4833 
   4834 
   4835                 } finally {dbg.exitDecision(65);}
   4836 
   4837                 switch (alt65) {
   4838 		case 1 :
   4839 		    dbg.enterAlt(1);
   4840 
   4841 		    // src/com/google/doclava/parser/Java.g:635:10: ',' typeArgument
   4842 		    {
   4843 		    dbg.location(635,10);
   4844 		    match(input,COMMA,FOLLOW_COMMA_in_typeArguments2709); if (state.failed) return ;
   4845 		    dbg.location(635,14);
   4846 		    pushFollow(FOLLOW_typeArgument_in_typeArguments2711);
   4847 		    typeArgument();
   4848 
   4849 		    state._fsp--;
   4850 		    if (state.failed) return ;
   4851 
   4852 		    }
   4853 		    break;
   4854 
   4855 		default :
   4856 		    break loop65;
   4857                 }
   4858             } while (true);
   4859             } finally {dbg.exitSubRule(65);}
   4860 
   4861             dbg.location(637,9);
   4862             match(input,GT,FOLLOW_GT_in_typeArguments2732); if (state.failed) return ;
   4863 
   4864             }
   4865 
   4866         }
   4867         catch (RecognitionException re) {
   4868             reportError(re);
   4869             recover(input,re);
   4870         }
   4871         finally {
   4872             if ( state.backtracking>0 ) { memoize(input, 35, typeArguments_StartIndex); }
   4873         }
   4874         dbg.location(638, 5);
   4875 
   4876         }
   4877         finally {
   4878             dbg.exitRule(getGrammarFileName(), "typeArguments");
   4879             decRuleLevel();
   4880             if ( getRuleLevel()==0 ) {dbg.terminate();}
   4881         }
   4882 
   4883         return ;
   4884     }
   4885     // $ANTLR end "typeArguments"
   4886 
   4887 
   4888     // $ANTLR start "typeArgument"
   4889     // src/com/google/doclava/parser/Java.g:640:1: typeArgument : ( type | '?' ( ( 'extends' | 'super' ) type )? );
   4890     public final void typeArgument() throws RecognitionException {
   4891         int typeArgument_StartIndex = input.index();
   4892         try { dbg.enterRule(getGrammarFileName(), "typeArgument");
   4893         if ( getRuleLevel()==0 ) {dbg.commence();}
   4894         incRuleLevel();
   4895         dbg.location(640, 1);
   4896 
   4897         try {
   4898             if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return ; }
   4899             // src/com/google/doclava/parser/Java.g:641:5: ( type | '?' ( ( 'extends' | 'super' ) type )? )
   4900             int alt67=2;
   4901             try { dbg.enterDecision(67, decisionCanBacktrack[67]);
   4902 
   4903             int LA67_0 = input.LA(1);
   4904 
   4905             if ( (LA67_0==IDENTIFIER||LA67_0==BOOLEAN||LA67_0==BYTE||LA67_0==CHAR||LA67_0==DOUBLE||LA67_0==FLOAT||LA67_0==INT||LA67_0==LONG||LA67_0==SHORT) ) {
   4906                 alt67=1;
   4907             }
   4908             else if ( (LA67_0==QUES) ) {
   4909                 alt67=2;
   4910             }
   4911             else {
   4912                 if (state.backtracking>0) {state.failed=true; return ;}
   4913                 NoViableAltException nvae =
   4914                     new NoViableAltException("", 67, 0, input);
   4915 
   4916                 dbg.recognitionException(nvae);
   4917                 throw nvae;
   4918             }
   4919             } finally {dbg.exitDecision(67);}
   4920 
   4921             switch (alt67) {
   4922                 case 1 :
   4923                     dbg.enterAlt(1);
   4924 
   4925                     // src/com/google/doclava/parser/Java.g:641:9: type
   4926                     {
   4927                     dbg.location(641,9);
   4928                     pushFollow(FOLLOW_type_in_typeArgument2751);
   4929                     type();
   4930 
   4931                     state._fsp--;
   4932                     if (state.failed) return ;
   4933 
   4934                     }
   4935                     break;
   4936                 case 2 :
   4937                     dbg.enterAlt(2);
   4938 
   4939                     // src/com/google/doclava/parser/Java.g:642:9: '?' ( ( 'extends' | 'super' ) type )?
   4940                     {
   4941                     dbg.location(642,9);
   4942                     match(input,QUES,FOLLOW_QUES_in_typeArgument2761); if (state.failed) return ;
   4943                     dbg.location(643,9);
   4944                     // src/com/google/doclava/parser/Java.g:643:9: ( ( 'extends' | 'super' ) type )?
   4945                     int alt66=2;
   4946                     try { dbg.enterSubRule(66);
   4947                     try { dbg.enterDecision(66, decisionCanBacktrack[66]);
   4948 
   4949                     int LA66_0 = input.LA(1);
   4950 
   4951                     if ( (LA66_0==EXTENDS||LA66_0==SUPER) ) {
   4952                         alt66=1;
   4953                     }
   4954                     } finally {dbg.exitDecision(66);}
   4955 
   4956                     switch (alt66) {
   4957                         case 1 :
   4958                             dbg.enterAlt(1);
   4959 
   4960                             // src/com/google/doclava/parser/Java.g:644:13: ( 'extends' | 'super' ) type
   4961                             {
   4962                             dbg.location(644,13);
   4963                             if ( input.LA(1)==EXTENDS||input.LA(1)==SUPER ) {
   4964                                 input.consume();
   4965                                 state.errorRecovery=false;state.failed=false;
   4966                             }
   4967                             else {
   4968                                 if (state.backtracking>0) {state.failed=true; return ;}
   4969                                 MismatchedSetException mse = new MismatchedSetException(null,input);
   4970                                 dbg.recognitionException(mse);
   4971                                 throw mse;
   4972                             }
   4973 
   4974                             dbg.location(647,13);
   4975                             pushFollow(FOLLOW_type_in_typeArgument2829);
   4976                             type();
   4977 
   4978                             state._fsp--;
   4979                             if (state.failed) return ;
   4980 
   4981                             }
   4982                             break;
   4983 
   4984                     }
   4985                     } finally {dbg.exitSubRule(66);}
   4986 
   4987 
   4988                     }
   4989                     break;
   4990 
   4991             }
   4992         }
   4993         catch (RecognitionException re) {
   4994             reportError(re);
   4995             recover(input,re);
   4996         }
   4997         finally {
   4998             if ( state.backtracking>0 ) { memoize(input, 36, typeArgument_StartIndex); }
   4999         }
   5000         dbg.location(649, 5);
   5001 
   5002         }
   5003         finally {
   5004             dbg.exitRule(getGrammarFileName(), "typeArgument");
   5005             decRuleLevel();
   5006             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5007         }
   5008 
   5009         return ;
   5010     }
   5011     // $ANTLR end "typeArgument"
   5012 
   5013 
   5014     // $ANTLR start "qualifiedNameList"
   5015     // src/com/google/doclava/parser/Java.g:651:1: qualifiedNameList : qualifiedName ( ',' qualifiedName )* ;
   5016     public final void qualifiedNameList() throws RecognitionException {
   5017         int qualifiedNameList_StartIndex = input.index();
   5018         try { dbg.enterRule(getGrammarFileName(), "qualifiedNameList");
   5019         if ( getRuleLevel()==0 ) {dbg.commence();}
   5020         incRuleLevel();
   5021         dbg.location(651, 1);
   5022 
   5023         try {
   5024             if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return ; }
   5025             // src/com/google/doclava/parser/Java.g:652:5: ( qualifiedName ( ',' qualifiedName )* )
   5026             dbg.enterAlt(1);
   5027 
   5028             // src/com/google/doclava/parser/Java.g:652:9: qualifiedName ( ',' qualifiedName )*
   5029             {
   5030             dbg.location(652,9);
   5031             pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2859);
   5032             qualifiedName();
   5033 
   5034             state._fsp--;
   5035             if (state.failed) return ;
   5036             dbg.location(653,9);
   5037             // src/com/google/doclava/parser/Java.g:653:9: ( ',' qualifiedName )*
   5038             try { dbg.enterSubRule(68);
   5039 
   5040             loop68:
   5041             do {
   5042                 int alt68=2;
   5043                 try { dbg.enterDecision(68, decisionCanBacktrack[68]);
   5044 
   5045                 int LA68_0 = input.LA(1);
   5046 
   5047                 if ( (LA68_0==COMMA) ) {
   5048                     alt68=1;
   5049                 }
   5050 
   5051 
   5052                 } finally {dbg.exitDecision(68);}
   5053 
   5054                 switch (alt68) {
   5055 		case 1 :
   5056 		    dbg.enterAlt(1);
   5057 
   5058 		    // src/com/google/doclava/parser/Java.g:653:10: ',' qualifiedName
   5059 		    {
   5060 		    dbg.location(653,10);
   5061 		    match(input,COMMA,FOLLOW_COMMA_in_qualifiedNameList2870); if (state.failed) return ;
   5062 		    dbg.location(653,14);
   5063 		    pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2872);
   5064 		    qualifiedName();
   5065 
   5066 		    state._fsp--;
   5067 		    if (state.failed) return ;
   5068 
   5069 		    }
   5070 		    break;
   5071 
   5072 		default :
   5073 		    break loop68;
   5074                 }
   5075             } while (true);
   5076             } finally {dbg.exitSubRule(68);}
   5077 
   5078 
   5079             }
   5080 
   5081         }
   5082         catch (RecognitionException re) {
   5083             reportError(re);
   5084             recover(input,re);
   5085         }
   5086         finally {
   5087             if ( state.backtracking>0 ) { memoize(input, 37, qualifiedNameList_StartIndex); }
   5088         }
   5089         dbg.location(655, 5);
   5090 
   5091         }
   5092         finally {
   5093             dbg.exitRule(getGrammarFileName(), "qualifiedNameList");
   5094             decRuleLevel();
   5095             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5096         }
   5097 
   5098         return ;
   5099     }
   5100     // $ANTLR end "qualifiedNameList"
   5101 
   5102 
   5103     // $ANTLR start "formalParameters"
   5104     // src/com/google/doclava/parser/Java.g:657:1: formalParameters : '(' ( formalParameterDecls )? ')' ;
   5105     public final void formalParameters() throws RecognitionException {
   5106         int formalParameters_StartIndex = input.index();
   5107         try { dbg.enterRule(getGrammarFileName(), "formalParameters");
   5108         if ( getRuleLevel()==0 ) {dbg.commence();}
   5109         incRuleLevel();
   5110         dbg.location(657, 1);
   5111 
   5112         try {
   5113             if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return ; }
   5114             // src/com/google/doclava/parser/Java.g:658:5: ( '(' ( formalParameterDecls )? ')' )
   5115             dbg.enterAlt(1);
   5116 
   5117             // src/com/google/doclava/parser/Java.g:658:9: '(' ( formalParameterDecls )? ')'
   5118             {
   5119             dbg.location(658,9);
   5120             match(input,LPAREN,FOLLOW_LPAREN_in_formalParameters2902); if (state.failed) return ;
   5121             dbg.location(659,9);
   5122             // src/com/google/doclava/parser/Java.g:659:9: ( formalParameterDecls )?
   5123             int alt69=2;
   5124             try { dbg.enterSubRule(69);
   5125             try { dbg.enterDecision(69, decisionCanBacktrack[69]);
   5126 
   5127             int LA69_0 = input.LA(1);
   5128 
   5129             if ( (LA69_0==IDENTIFIER||LA69_0==BOOLEAN||LA69_0==BYTE||LA69_0==CHAR||LA69_0==DOUBLE||LA69_0==FINAL||LA69_0==FLOAT||LA69_0==INT||LA69_0==LONG||LA69_0==SHORT||LA69_0==MONKEYS_AT) ) {
   5130                 alt69=1;
   5131             }
   5132             } finally {dbg.exitDecision(69);}
   5133 
   5134             switch (alt69) {
   5135                 case 1 :
   5136                     dbg.enterAlt(1);
   5137 
   5138                     // src/com/google/doclava/parser/Java.g:659:10: formalParameterDecls
   5139                     {
   5140                     dbg.location(659,10);
   5141                     pushFollow(FOLLOW_formalParameterDecls_in_formalParameters2913);
   5142                     formalParameterDecls();
   5143 
   5144                     state._fsp--;
   5145                     if (state.failed) return ;
   5146 
   5147                     }
   5148                     break;
   5149 
   5150             }
   5151             } finally {dbg.exitSubRule(69);}
   5152 
   5153             dbg.location(661,9);
   5154             match(input,RPAREN,FOLLOW_RPAREN_in_formalParameters2934); if (state.failed) return ;
   5155 
   5156             }
   5157 
   5158         }
   5159         catch (RecognitionException re) {
   5160             reportError(re);
   5161             recover(input,re);
   5162         }
   5163         finally {
   5164             if ( state.backtracking>0 ) { memoize(input, 38, formalParameters_StartIndex); }
   5165         }
   5166         dbg.location(662, 5);
   5167 
   5168         }
   5169         finally {
   5170             dbg.exitRule(getGrammarFileName(), "formalParameters");
   5171             decRuleLevel();
   5172             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5173         }
   5174 
   5175         return ;
   5176     }
   5177     // $ANTLR end "formalParameters"
   5178 
   5179 
   5180     // $ANTLR start "formalParameterDecls"
   5181     // src/com/google/doclava/parser/Java.g:664:1: formalParameterDecls : ( ellipsisParameterDecl | normalParameterDecl ( ',' normalParameterDecl )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl );
   5182     public final void formalParameterDecls() throws RecognitionException {
   5183         int formalParameterDecls_StartIndex = input.index();
   5184         try { dbg.enterRule(getGrammarFileName(), "formalParameterDecls");
   5185         if ( getRuleLevel()==0 ) {dbg.commence();}
   5186         incRuleLevel();
   5187         dbg.location(664, 1);
   5188 
   5189         try {
   5190             if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return ; }
   5191             // src/com/google/doclava/parser/Java.g:665:5: ( ellipsisParameterDecl | normalParameterDecl ( ',' normalParameterDecl )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl )
   5192             int alt72=3;
   5193             try { dbg.enterDecision(72, decisionCanBacktrack[72]);
   5194 
   5195             switch ( input.LA(1) ) {
   5196             case FINAL:
   5197                 {
   5198                 int LA72_1 = input.LA(2);
   5199 
   5200                 if ( (synpred96_Java()) ) {
   5201                     alt72=1;
   5202                 }
   5203                 else if ( (synpred98_Java()) ) {
   5204                     alt72=2;
   5205                 }
   5206                 else if ( (true) ) {
   5207                     alt72=3;
   5208                 }
   5209                 else {
   5210                     if (state.backtracking>0) {state.failed=true; return ;}
   5211                     NoViableAltException nvae =
   5212                         new NoViableAltException("", 72, 1, input);
   5213 
   5214                     dbg.recognitionException(nvae);
   5215                     throw nvae;
   5216                 }
   5217                 }
   5218                 break;
   5219             case MONKEYS_AT:
   5220                 {
   5221                 int LA72_2 = input.LA(2);
   5222 
   5223                 if ( (synpred96_Java()) ) {
   5224                     alt72=1;
   5225                 }
   5226                 else if ( (synpred98_Java()) ) {
   5227                     alt72=2;
   5228                 }
   5229                 else if ( (true) ) {
   5230                     alt72=3;
   5231                 }
   5232                 else {
   5233                     if (state.backtracking>0) {state.failed=true; return ;}
   5234                     NoViableAltException nvae =
   5235                         new NoViableAltException("", 72, 2, input);
   5236 
   5237                     dbg.recognitionException(nvae);
   5238                     throw nvae;
   5239                 }
   5240                 }
   5241                 break;
   5242             case IDENTIFIER:
   5243                 {
   5244                 int LA72_3 = input.LA(2);
   5245 
   5246                 if ( (synpred96_Java()) ) {
   5247                     alt72=1;
   5248                 }
   5249                 else if ( (synpred98_Java()) ) {
   5250                     alt72=2;
   5251                 }
   5252                 else if ( (true) ) {
   5253                     alt72=3;
   5254                 }
   5255                 else {
   5256                     if (state.backtracking>0) {state.failed=true; return ;}
   5257                     NoViableAltException nvae =
   5258                         new NoViableAltException("", 72, 3, input);
   5259 
   5260                     dbg.recognitionException(nvae);
   5261                     throw nvae;
   5262                 }
   5263                 }
   5264                 break;
   5265             case BOOLEAN:
   5266             case BYTE:
   5267             case CHAR:
   5268             case DOUBLE:
   5269             case FLOAT:
   5270             case INT:
   5271             case LONG:
   5272             case SHORT:
   5273                 {
   5274                 int LA72_4 = input.LA(2);
   5275 
   5276                 if ( (synpred96_Java()) ) {
   5277                     alt72=1;
   5278                 }
   5279                 else if ( (synpred98_Java()) ) {
   5280                     alt72=2;
   5281                 }
   5282                 else if ( (true) ) {
   5283                     alt72=3;
   5284                 }
   5285                 else {
   5286                     if (state.backtracking>0) {state.failed=true; return ;}
   5287                     NoViableAltException nvae =
   5288                         new NoViableAltException("", 72, 4, input);
   5289 
   5290                     dbg.recognitionException(nvae);
   5291                     throw nvae;
   5292                 }
   5293                 }
   5294                 break;
   5295             default:
   5296                 if (state.backtracking>0) {state.failed=true; return ;}
   5297                 NoViableAltException nvae =
   5298                     new NoViableAltException("", 72, 0, input);
   5299 
   5300                 dbg.recognitionException(nvae);
   5301                 throw nvae;
   5302             }
   5303 
   5304             } finally {dbg.exitDecision(72);}
   5305 
   5306             switch (alt72) {
   5307                 case 1 :
   5308                     dbg.enterAlt(1);
   5309 
   5310                     // src/com/google/doclava/parser/Java.g:665:9: ellipsisParameterDecl
   5311                     {
   5312                     dbg.location(665,9);
   5313                     pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls2953);
   5314                     ellipsisParameterDecl();
   5315 
   5316                     state._fsp--;
   5317                     if (state.failed) return ;
   5318 
   5319                     }
   5320                     break;
   5321                 case 2 :
   5322                     dbg.enterAlt(2);
   5323 
   5324                     // src/com/google/doclava/parser/Java.g:666:9: normalParameterDecl ( ',' normalParameterDecl )*
   5325                     {
   5326                     dbg.location(666,9);
   5327                     pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2963);
   5328                     normalParameterDecl();
   5329 
   5330                     state._fsp--;
   5331                     if (state.failed) return ;
   5332                     dbg.location(667,9);
   5333                     // src/com/google/doclava/parser/Java.g:667:9: ( ',' normalParameterDecl )*
   5334                     try { dbg.enterSubRule(70);
   5335 
   5336                     loop70:
   5337                     do {
   5338                         int alt70=2;
   5339                         try { dbg.enterDecision(70, decisionCanBacktrack[70]);
   5340 
   5341                         int LA70_0 = input.LA(1);
   5342 
   5343                         if ( (LA70_0==COMMA) ) {
   5344                             alt70=1;
   5345                         }
   5346 
   5347 
   5348                         } finally {dbg.exitDecision(70);}
   5349 
   5350                         switch (alt70) {
   5351 			case 1 :
   5352 			    dbg.enterAlt(1);
   5353 
   5354 			    // src/com/google/doclava/parser/Java.g:667:10: ',' normalParameterDecl
   5355 			    {
   5356 			    dbg.location(667,10);
   5357 			    match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls2974); if (state.failed) return ;
   5358 			    dbg.location(667,14);
   5359 			    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2976);
   5360 			    normalParameterDecl();
   5361 
   5362 			    state._fsp--;
   5363 			    if (state.failed) return ;
   5364 
   5365 			    }
   5366 			    break;
   5367 
   5368 			default :
   5369 			    break loop70;
   5370                         }
   5371                     } while (true);
   5372                     } finally {dbg.exitSubRule(70);}
   5373 
   5374 
   5375                     }
   5376                     break;
   5377                 case 3 :
   5378                     dbg.enterAlt(3);
   5379 
   5380                     // src/com/google/doclava/parser/Java.g:669:9: ( normalParameterDecl ',' )+ ellipsisParameterDecl
   5381                     {
   5382                     dbg.location(669,9);
   5383                     // src/com/google/doclava/parser/Java.g:669:9: ( normalParameterDecl ',' )+
   5384                     int cnt71=0;
   5385                     try { dbg.enterSubRule(71);
   5386 
   5387                     loop71:
   5388                     do {
   5389                         int alt71=2;
   5390                         try { dbg.enterDecision(71, decisionCanBacktrack[71]);
   5391 
   5392                         switch ( input.LA(1) ) {
   5393                         case FINAL:
   5394                             {
   5395                             int LA71_1 = input.LA(2);
   5396 
   5397                             if ( (synpred99_Java()) ) {
   5398                                 alt71=1;
   5399                             }
   5400 
   5401 
   5402                             }
   5403                             break;
   5404                         case MONKEYS_AT:
   5405                             {
   5406                             int LA71_2 = input.LA(2);
   5407 
   5408                             if ( (synpred99_Java()) ) {
   5409                                 alt71=1;
   5410                             }
   5411 
   5412 
   5413                             }
   5414                             break;
   5415                         case IDENTIFIER:
   5416                             {
   5417                             int LA71_3 = input.LA(2);
   5418 
   5419                             if ( (synpred99_Java()) ) {
   5420                                 alt71=1;
   5421                             }
   5422 
   5423 
   5424                             }
   5425                             break;
   5426                         case BOOLEAN:
   5427                         case BYTE:
   5428                         case CHAR:
   5429                         case DOUBLE:
   5430                         case FLOAT:
   5431                         case INT:
   5432                         case LONG:
   5433                         case SHORT:
   5434                             {
   5435                             int LA71_4 = input.LA(2);
   5436 
   5437                             if ( (synpred99_Java()) ) {
   5438                                 alt71=1;
   5439                             }
   5440 
   5441 
   5442                             }
   5443                             break;
   5444 
   5445                         }
   5446 
   5447                         } finally {dbg.exitDecision(71);}
   5448 
   5449                         switch (alt71) {
   5450 			case 1 :
   5451 			    dbg.enterAlt(1);
   5452 
   5453 			    // src/com/google/doclava/parser/Java.g:669:10: normalParameterDecl ','
   5454 			    {
   5455 			    dbg.location(669,10);
   5456 			    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2998);
   5457 			    normalParameterDecl();
   5458 
   5459 			    state._fsp--;
   5460 			    if (state.failed) return ;
   5461 			    dbg.location(670,9);
   5462 			    match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls3008); if (state.failed) return ;
   5463 
   5464 			    }
   5465 			    break;
   5466 
   5467 			default :
   5468 			    if ( cnt71 >= 1 ) break loop71;
   5469 			    if (state.backtracking>0) {state.failed=true; return ;}
   5470                                 EarlyExitException eee =
   5471                                     new EarlyExitException(71, input);
   5472                                 dbg.recognitionException(eee);
   5473 
   5474                                 throw eee;
   5475                         }
   5476                         cnt71++;
   5477                     } while (true);
   5478                     } finally {dbg.exitSubRule(71);}
   5479 
   5480                     dbg.location(672,9);
   5481                     pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3029);
   5482                     ellipsisParameterDecl();
   5483 
   5484                     state._fsp--;
   5485                     if (state.failed) return ;
   5486 
   5487                     }
   5488                     break;
   5489 
   5490             }
   5491         }
   5492         catch (RecognitionException re) {
   5493             reportError(re);
   5494             recover(input,re);
   5495         }
   5496         finally {
   5497             if ( state.backtracking>0 ) { memoize(input, 39, formalParameterDecls_StartIndex); }
   5498         }
   5499         dbg.location(673, 5);
   5500 
   5501         }
   5502         finally {
   5503             dbg.exitRule(getGrammarFileName(), "formalParameterDecls");
   5504             decRuleLevel();
   5505             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5506         }
   5507 
   5508         return ;
   5509     }
   5510     // $ANTLR end "formalParameterDecls"
   5511 
   5512 
   5513     // $ANTLR start "normalParameterDecl"
   5514     // src/com/google/doclava/parser/Java.g:675:1: normalParameterDecl : variableModifiers type IDENTIFIER ( '[' ']' )* ;
   5515     public final void normalParameterDecl() throws RecognitionException {
   5516         int normalParameterDecl_StartIndex = input.index();
   5517         try { dbg.enterRule(getGrammarFileName(), "normalParameterDecl");
   5518         if ( getRuleLevel()==0 ) {dbg.commence();}
   5519         incRuleLevel();
   5520         dbg.location(675, 1);
   5521 
   5522         try {
   5523             if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return ; }
   5524             // src/com/google/doclava/parser/Java.g:676:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* )
   5525             dbg.enterAlt(1);
   5526 
   5527             // src/com/google/doclava/parser/Java.g:676:9: variableModifiers type IDENTIFIER ( '[' ']' )*
   5528             {
   5529             dbg.location(676,9);
   5530             pushFollow(FOLLOW_variableModifiers_in_normalParameterDecl3048);
   5531             variableModifiers();
   5532 
   5533             state._fsp--;
   5534             if (state.failed) return ;
   5535             dbg.location(676,27);
   5536             pushFollow(FOLLOW_type_in_normalParameterDecl3050);
   5537             type();
   5538 
   5539             state._fsp--;
   5540             if (state.failed) return ;
   5541             dbg.location(676,32);
   5542             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalParameterDecl3052); if (state.failed) return ;
   5543             dbg.location(677,9);
   5544             // src/com/google/doclava/parser/Java.g:677:9: ( '[' ']' )*
   5545             try { dbg.enterSubRule(73);
   5546 
   5547             loop73:
   5548             do {
   5549                 int alt73=2;
   5550                 try { dbg.enterDecision(73, decisionCanBacktrack[73]);
   5551 
   5552                 int LA73_0 = input.LA(1);
   5553 
   5554                 if ( (LA73_0==LBRACKET) ) {
   5555                     alt73=1;
   5556                 }
   5557 
   5558 
   5559                 } finally {dbg.exitDecision(73);}
   5560 
   5561                 switch (alt73) {
   5562 		case 1 :
   5563 		    dbg.enterAlt(1);
   5564 
   5565 		    // src/com/google/doclava/parser/Java.g:677:10: '[' ']'
   5566 		    {
   5567 		    dbg.location(677,10);
   5568 		    match(input,LBRACKET,FOLLOW_LBRACKET_in_normalParameterDecl3063); if (state.failed) return ;
   5569 		    dbg.location(677,14);
   5570 		    match(input,RBRACKET,FOLLOW_RBRACKET_in_normalParameterDecl3065); if (state.failed) return ;
   5571 
   5572 		    }
   5573 		    break;
   5574 
   5575 		default :
   5576 		    break loop73;
   5577                 }
   5578             } while (true);
   5579             } finally {dbg.exitSubRule(73);}
   5580 
   5581 
   5582             }
   5583 
   5584         }
   5585         catch (RecognitionException re) {
   5586             reportError(re);
   5587             recover(input,re);
   5588         }
   5589         finally {
   5590             if ( state.backtracking>0 ) { memoize(input, 40, normalParameterDecl_StartIndex); }
   5591         }
   5592         dbg.location(679, 5);
   5593 
   5594         }
   5595         finally {
   5596             dbg.exitRule(getGrammarFileName(), "normalParameterDecl");
   5597             decRuleLevel();
   5598             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5599         }
   5600 
   5601         return ;
   5602     }
   5603     // $ANTLR end "normalParameterDecl"
   5604 
   5605 
   5606     // $ANTLR start "ellipsisParameterDecl"
   5607     // src/com/google/doclava/parser/Java.g:681:1: ellipsisParameterDecl : variableModifiers type '...' IDENTIFIER ;
   5608     public final void ellipsisParameterDecl() throws RecognitionException {
   5609         int ellipsisParameterDecl_StartIndex = input.index();
   5610         try { dbg.enterRule(getGrammarFileName(), "ellipsisParameterDecl");
   5611         if ( getRuleLevel()==0 ) {dbg.commence();}
   5612         incRuleLevel();
   5613         dbg.location(681, 1);
   5614 
   5615         try {
   5616             if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return ; }
   5617             // src/com/google/doclava/parser/Java.g:682:5: ( variableModifiers type '...' IDENTIFIER )
   5618             dbg.enterAlt(1);
   5619 
   5620             // src/com/google/doclava/parser/Java.g:682:9: variableModifiers type '...' IDENTIFIER
   5621             {
   5622             dbg.location(682,9);
   5623             pushFollow(FOLLOW_variableModifiers_in_ellipsisParameterDecl3095);
   5624             variableModifiers();
   5625 
   5626             state._fsp--;
   5627             if (state.failed) return ;
   5628             dbg.location(683,9);
   5629             pushFollow(FOLLOW_type_in_ellipsisParameterDecl3105);
   5630             type();
   5631 
   5632             state._fsp--;
   5633             if (state.failed) return ;
   5634             dbg.location(683,15);
   5635             match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3108); if (state.failed) return ;
   5636             dbg.location(684,9);
   5637             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3118); if (state.failed) return ;
   5638 
   5639             }
   5640 
   5641         }
   5642         catch (RecognitionException re) {
   5643             reportError(re);
   5644             recover(input,re);
   5645         }
   5646         finally {
   5647             if ( state.backtracking>0 ) { memoize(input, 41, ellipsisParameterDecl_StartIndex); }
   5648         }
   5649         dbg.location(685, 5);
   5650 
   5651         }
   5652         finally {
   5653             dbg.exitRule(getGrammarFileName(), "ellipsisParameterDecl");
   5654             decRuleLevel();
   5655             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5656         }
   5657 
   5658         return ;
   5659     }
   5660     // $ANTLR end "ellipsisParameterDecl"
   5661 
   5662 
   5663     // $ANTLR start "explicitConstructorInvocation"
   5664     // src/com/google/doclava/parser/Java.g:688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' );
   5665     public final void explicitConstructorInvocation() throws RecognitionException {
   5666         int explicitConstructorInvocation_StartIndex = input.index();
   5667         try { dbg.enterRule(getGrammarFileName(), "explicitConstructorInvocation");
   5668         if ( getRuleLevel()==0 ) {dbg.commence();}
   5669         incRuleLevel();
   5670         dbg.location(688, 1);
   5671 
   5672         try {
   5673             if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return ; }
   5674             // src/com/google/doclava/parser/Java.g:689:5: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' )
   5675             int alt76=2;
   5676             try { dbg.enterDecision(76, decisionCanBacktrack[76]);
   5677 
   5678             try {
   5679                 isCyclicDecision = true;
   5680                 alt76 = dfa76.predict(input);
   5681             }
   5682             catch (NoViableAltException nvae) {
   5683                 dbg.recognitionException(nvae);
   5684                 throw nvae;
   5685             }
   5686             } finally {dbg.exitDecision(76);}
   5687 
   5688             switch (alt76) {
   5689                 case 1 :
   5690                     dbg.enterAlt(1);
   5691 
   5692                     // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';'
   5693                     {
   5694                     dbg.location(689,9);
   5695                     // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )?
   5696                     int alt74=2;
   5697                     try { dbg.enterSubRule(74);
   5698                     try { dbg.enterDecision(74, decisionCanBacktrack[74]);
   5699 
   5700                     int LA74_0 = input.LA(1);
   5701 
   5702                     if ( (LA74_0==LT) ) {
   5703                         alt74=1;
   5704                     }
   5705                     } finally {dbg.exitDecision(74);}
   5706 
   5707                     switch (alt74) {
   5708                         case 1 :
   5709                             dbg.enterAlt(1);
   5710 
   5711                             // src/com/google/doclava/parser/Java.g:689:10: nonWildcardTypeArguments
   5712                             {
   5713                             dbg.location(689,10);
   5714                             pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3139);
   5715                             nonWildcardTypeArguments();
   5716 
   5717                             state._fsp--;
   5718                             if (state.failed) return ;
   5719 
   5720                             }
   5721                             break;
   5722 
   5723                     }
   5724                     } finally {dbg.exitSubRule(74);}
   5725 
   5726                     dbg.location(691,9);
   5727                     if ( input.LA(1)==SUPER||input.LA(1)==THIS ) {
   5728                         input.consume();
   5729                         state.errorRecovery=false;state.failed=false;
   5730                     }
   5731                     else {
   5732                         if (state.backtracking>0) {state.failed=true; return ;}
   5733                         MismatchedSetException mse = new MismatchedSetException(null,input);
   5734                         dbg.recognitionException(mse);
   5735                         throw mse;
   5736                     }
   5737 
   5738                     dbg.location(694,9);
   5739                     pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3197);
   5740                     arguments();
   5741 
   5742                     state._fsp--;
   5743                     if (state.failed) return ;
   5744                     dbg.location(694,19);
   5745                     match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3199); if (state.failed) return ;
   5746 
   5747                     }
   5748                     break;
   5749                 case 2 :
   5750                     dbg.enterAlt(2);
   5751 
   5752                     // src/com/google/doclava/parser/Java.g:696:9: primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';'
   5753                     {
   5754                     dbg.location(696,9);
   5755                     pushFollow(FOLLOW_primary_in_explicitConstructorInvocation3210);
   5756                     primary();
   5757 
   5758                     state._fsp--;
   5759                     if (state.failed) return ;
   5760                     dbg.location(697,9);
   5761                     match(input,DOT,FOLLOW_DOT_in_explicitConstructorInvocation3220); if (state.failed) return ;
   5762                     dbg.location(698,9);
   5763                     // src/com/google/doclava/parser/Java.g:698:9: ( nonWildcardTypeArguments )?
   5764                     int alt75=2;
   5765                     try { dbg.enterSubRule(75);
   5766                     try { dbg.enterDecision(75, decisionCanBacktrack[75]);
   5767 
   5768                     int LA75_0 = input.LA(1);
   5769 
   5770                     if ( (LA75_0==LT) ) {
   5771                         alt75=1;
   5772                     }
   5773                     } finally {dbg.exitDecision(75);}
   5774 
   5775                     switch (alt75) {
   5776                         case 1 :
   5777                             dbg.enterAlt(1);
   5778 
   5779                             // src/com/google/doclava/parser/Java.g:698:10: nonWildcardTypeArguments
   5780                             {
   5781                             dbg.location(698,10);
   5782                             pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3231);
   5783                             nonWildcardTypeArguments();
   5784 
   5785                             state._fsp--;
   5786                             if (state.failed) return ;
   5787 
   5788                             }
   5789                             break;
   5790 
   5791                     }
   5792                     } finally {dbg.exitSubRule(75);}
   5793 
   5794                     dbg.location(700,9);
   5795                     match(input,SUPER,FOLLOW_SUPER_in_explicitConstructorInvocation3252); if (state.failed) return ;
   5796                     dbg.location(701,9);
   5797                     pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3262);
   5798                     arguments();
   5799 
   5800                     state._fsp--;
   5801                     if (state.failed) return ;
   5802                     dbg.location(701,19);
   5803                     match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3264); if (state.failed) return ;
   5804 
   5805                     }
   5806                     break;
   5807 
   5808             }
   5809         }
   5810         catch (RecognitionException re) {
   5811             reportError(re);
   5812             recover(input,re);
   5813         }
   5814         finally {
   5815             if ( state.backtracking>0 ) { memoize(input, 42, explicitConstructorInvocation_StartIndex); }
   5816         }
   5817         dbg.location(702, 5);
   5818 
   5819         }
   5820         finally {
   5821             dbg.exitRule(getGrammarFileName(), "explicitConstructorInvocation");
   5822             decRuleLevel();
   5823             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5824         }
   5825 
   5826         return ;
   5827     }
   5828     // $ANTLR end "explicitConstructorInvocation"
   5829 
   5830 
   5831     // $ANTLR start "qualifiedName"
   5832     // src/com/google/doclava/parser/Java.g:704:1: qualifiedName : IDENTIFIER ( '.' IDENTIFIER )* ;
   5833     public final void qualifiedName() throws RecognitionException {
   5834         int qualifiedName_StartIndex = input.index();
   5835         try { dbg.enterRule(getGrammarFileName(), "qualifiedName");
   5836         if ( getRuleLevel()==0 ) {dbg.commence();}
   5837         incRuleLevel();
   5838         dbg.location(704, 1);
   5839 
   5840         try {
   5841             if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return ; }
   5842             // src/com/google/doclava/parser/Java.g:705:5: ( IDENTIFIER ( '.' IDENTIFIER )* )
   5843             dbg.enterAlt(1);
   5844 
   5845             // src/com/google/doclava/parser/Java.g:705:9: IDENTIFIER ( '.' IDENTIFIER )*
   5846             {
   5847             dbg.location(705,9);
   5848             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3283); if (state.failed) return ;
   5849             dbg.location(706,9);
   5850             // src/com/google/doclava/parser/Java.g:706:9: ( '.' IDENTIFIER )*
   5851             try { dbg.enterSubRule(77);
   5852 
   5853             loop77:
   5854             do {
   5855                 int alt77=2;
   5856                 try { dbg.enterDecision(77, decisionCanBacktrack[77]);
   5857 
   5858                 int LA77_0 = input.LA(1);
   5859 
   5860                 if ( (LA77_0==DOT) ) {
   5861                     alt77=1;
   5862                 }
   5863 
   5864 
   5865                 } finally {dbg.exitDecision(77);}
   5866 
   5867                 switch (alt77) {
   5868 		case 1 :
   5869 		    dbg.enterAlt(1);
   5870 
   5871 		    // src/com/google/doclava/parser/Java.g:706:10: '.' IDENTIFIER
   5872 		    {
   5873 		    dbg.location(706,10);
   5874 		    match(input,DOT,FOLLOW_DOT_in_qualifiedName3294); if (state.failed) return ;
   5875 		    dbg.location(706,14);
   5876 		    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3296); if (state.failed) return ;
   5877 
   5878 		    }
   5879 		    break;
   5880 
   5881 		default :
   5882 		    break loop77;
   5883                 }
   5884             } while (true);
   5885             } finally {dbg.exitSubRule(77);}
   5886 
   5887 
   5888             }
   5889 
   5890         }
   5891         catch (RecognitionException re) {
   5892             reportError(re);
   5893             recover(input,re);
   5894         }
   5895         finally {
   5896             if ( state.backtracking>0 ) { memoize(input, 43, qualifiedName_StartIndex); }
   5897         }
   5898         dbg.location(708, 5);
   5899 
   5900         }
   5901         finally {
   5902             dbg.exitRule(getGrammarFileName(), "qualifiedName");
   5903             decRuleLevel();
   5904             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5905         }
   5906 
   5907         return ;
   5908     }
   5909     // $ANTLR end "qualifiedName"
   5910 
   5911 
   5912     // $ANTLR start "annotations"
   5913     // src/com/google/doclava/parser/Java.g:710:1: annotations : ( annotation )+ ;
   5914     public final void annotations() throws RecognitionException {
   5915         int annotations_StartIndex = input.index();
   5916         try { dbg.enterRule(getGrammarFileName(), "annotations");
   5917         if ( getRuleLevel()==0 ) {dbg.commence();}
   5918         incRuleLevel();
   5919         dbg.location(710, 1);
   5920 
   5921         try {
   5922             if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return ; }
   5923             // src/com/google/doclava/parser/Java.g:711:5: ( ( annotation )+ )
   5924             dbg.enterAlt(1);
   5925 
   5926             // src/com/google/doclava/parser/Java.g:711:9: ( annotation )+
   5927             {
   5928             dbg.location(711,9);
   5929             // src/com/google/doclava/parser/Java.g:711:9: ( annotation )+
   5930             int cnt78=0;
   5931             try { dbg.enterSubRule(78);
   5932 
   5933             loop78:
   5934             do {
   5935                 int alt78=2;
   5936                 try { dbg.enterDecision(78, decisionCanBacktrack[78]);
   5937 
   5938                 int LA78_0 = input.LA(1);
   5939 
   5940                 if ( (LA78_0==MONKEYS_AT) ) {
   5941                     alt78=1;
   5942                 }
   5943 
   5944 
   5945                 } finally {dbg.exitDecision(78);}
   5946 
   5947                 switch (alt78) {
   5948 		case 1 :
   5949 		    dbg.enterAlt(1);
   5950 
   5951 		    // src/com/google/doclava/parser/Java.g:711:10: annotation
   5952 		    {
   5953 		    dbg.location(711,10);
   5954 		    pushFollow(FOLLOW_annotation_in_annotations3327);
   5955 		    annotation();
   5956 
   5957 		    state._fsp--;
   5958 		    if (state.failed) return ;
   5959 
   5960 		    }
   5961 		    break;
   5962 
   5963 		default :
   5964 		    if ( cnt78 >= 1 ) break loop78;
   5965 		    if (state.backtracking>0) {state.failed=true; return ;}
   5966                         EarlyExitException eee =
   5967                             new EarlyExitException(78, input);
   5968                         dbg.recognitionException(eee);
   5969 
   5970                         throw eee;
   5971                 }
   5972                 cnt78++;
   5973             } while (true);
   5974             } finally {dbg.exitSubRule(78);}
   5975 
   5976 
   5977             }
   5978 
   5979         }
   5980         catch (RecognitionException re) {
   5981             reportError(re);
   5982             recover(input,re);
   5983         }
   5984         finally {
   5985             if ( state.backtracking>0 ) { memoize(input, 44, annotations_StartIndex); }
   5986         }
   5987         dbg.location(713, 5);
   5988 
   5989         }
   5990         finally {
   5991             dbg.exitRule(getGrammarFileName(), "annotations");
   5992             decRuleLevel();
   5993             if ( getRuleLevel()==0 ) {dbg.terminate();}
   5994         }
   5995 
   5996         return ;
   5997     }
   5998     // $ANTLR end "annotations"
   5999 
   6000 
   6001     // $ANTLR start "annotation"
   6002     // src/com/google/doclava/parser/Java.g:715:1: annotation : '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? ;
   6003     public final void annotation() throws RecognitionException {
   6004         int annotation_StartIndex = input.index();
   6005         try { dbg.enterRule(getGrammarFileName(), "annotation");
   6006         if ( getRuleLevel()==0 ) {dbg.commence();}
   6007         incRuleLevel();
   6008         dbg.location(715, 1);
   6009 
   6010         try {
   6011             if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return ; }
   6012             // src/com/google/doclava/parser/Java.g:720:5: ( '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? )
   6013             dbg.enterAlt(1);
   6014 
   6015             // src/com/google/doclava/parser/Java.g:720:9: '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )?
   6016             {
   6017             dbg.location(720,9);
   6018             match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotation3359); if (state.failed) return ;
   6019             dbg.location(720,13);
   6020             pushFollow(FOLLOW_qualifiedName_in_annotation3361);
   6021             qualifiedName();
   6022 
   6023             state._fsp--;
   6024             if (state.failed) return ;
   6025             dbg.location(721,9);
   6026             // src/com/google/doclava/parser/Java.g:721:9: ( '(' ( elementValuePairs | elementValue )? ')' )?
   6027             int alt80=2;
   6028             try { dbg.enterSubRule(80);
   6029             try { dbg.enterDecision(80, decisionCanBacktrack[80]);
   6030 
   6031             int LA80_0 = input.LA(1);
   6032 
   6033             if ( (LA80_0==LPAREN) ) {
   6034                 alt80=1;
   6035             }
   6036             } finally {dbg.exitDecision(80);}
   6037 
   6038             switch (alt80) {
   6039                 case 1 :
   6040                     dbg.enterAlt(1);
   6041 
   6042                     // src/com/google/doclava/parser/Java.g:721:13: '(' ( elementValuePairs | elementValue )? ')'
   6043                     {
   6044                     dbg.location(721,13);
   6045                     match(input,LPAREN,FOLLOW_LPAREN_in_annotation3375); if (state.failed) return ;
   6046                     dbg.location(722,19);
   6047                     // src/com/google/doclava/parser/Java.g:722:19: ( elementValuePairs | elementValue )?
   6048                     int alt79=3;
   6049                     try { dbg.enterSubRule(79);
   6050                     try { dbg.enterDecision(79, decisionCanBacktrack[79]);
   6051 
   6052                     int LA79_0 = input.LA(1);
   6053 
   6054                     if ( (LA79_0==IDENTIFIER) ) {
   6055                         int LA79_1 = input.LA(2);
   6056 
   6057                         if ( (LA79_1==EQ) ) {
   6058                             alt79=1;
   6059                         }
   6060                         else if ( (LA79_1==INSTANCEOF||(LA79_1>=LPAREN && LA79_1<=RPAREN)||LA79_1==LBRACKET||LA79_1==DOT||LA79_1==QUES||(LA79_1>=EQEQ && LA79_1<=PERCENT)||(LA79_1>=BANGEQ && LA79_1<=LT)) ) {
   6061                             alt79=2;
   6062                         }
   6063                     }
   6064                     else if ( ((LA79_0>=INTLITERAL && LA79_0<=NULL)||LA79_0==BOOLEAN||LA79_0==BYTE||LA79_0==CHAR||LA79_0==DOUBLE||LA79_0==FLOAT||LA79_0==INT||LA79_0==LONG||LA79_0==NEW||LA79_0==SHORT||LA79_0==SUPER||LA79_0==THIS||LA79_0==VOID||LA79_0==LPAREN||LA79_0==LBRACE||(LA79_0>=BANG && LA79_0<=TILDE)||(LA79_0>=PLUSPLUS && LA79_0<=SUB)||LA79_0==MONKEYS_AT) ) {
   6065                         alt79=2;
   6066                     }
   6067                     } finally {dbg.exitDecision(79);}
   6068 
   6069                     switch (alt79) {
   6070                         case 1 :
   6071                             dbg.enterAlt(1);
   6072 
   6073                             // src/com/google/doclava/parser/Java.g:722:23: elementValuePairs
   6074                             {
   6075                             dbg.location(722,23);
   6076                             pushFollow(FOLLOW_elementValuePairs_in_annotation3399);
   6077                             elementValuePairs();
   6078 
   6079                             state._fsp--;
   6080                             if (state.failed) return ;
   6081 
   6082                             }
   6083                             break;
   6084                         case 2 :
   6085                             dbg.enterAlt(2);
   6086 
   6087                             // src/com/google/doclava/parser/Java.g:723:23: elementValue
   6088                             {
   6089                             dbg.location(723,23);
   6090                             pushFollow(FOLLOW_elementValue_in_annotation3423);
   6091                             elementValue();
   6092 
   6093                             state._fsp--;
   6094                             if (state.failed) return ;
   6095 
   6096                             }
   6097                             break;
   6098 
   6099                     }
   6100                     } finally {dbg.exitSubRule(79);}
   6101 
   6102                     dbg.location(725,13);
   6103                     match(input,RPAREN,FOLLOW_RPAREN_in_annotation3458); if (state.failed) return ;
   6104 
   6105                     }
   6106                     break;
   6107 
   6108             }
   6109             } finally {dbg.exitSubRule(80);}
   6110 
   6111 
   6112             }
   6113 
   6114         }
   6115         catch (RecognitionException re) {
   6116             reportError(re);
   6117             recover(input,re);
   6118         }
   6119         finally {
   6120             if ( state.backtracking>0 ) { memoize(input, 45, annotation_StartIndex); }
   6121         }
   6122         dbg.location(727, 5);
   6123 
   6124         }
   6125         finally {
   6126             dbg.exitRule(getGrammarFileName(), "annotation");
   6127             decRuleLevel();
   6128             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6129         }
   6130 
   6131         return ;
   6132     }
   6133     // $ANTLR end "annotation"
   6134 
   6135 
   6136     // $ANTLR start "elementValuePairs"
   6137     // src/com/google/doclava/parser/Java.g:729:1: elementValuePairs : elementValuePair ( ',' elementValuePair )* ;
   6138     public final void elementValuePairs() throws RecognitionException {
   6139         int elementValuePairs_StartIndex = input.index();
   6140         try { dbg.enterRule(getGrammarFileName(), "elementValuePairs");
   6141         if ( getRuleLevel()==0 ) {dbg.commence();}
   6142         incRuleLevel();
   6143         dbg.location(729, 1);
   6144 
   6145         try {
   6146             if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return ; }
   6147             // src/com/google/doclava/parser/Java.g:730:5: ( elementValuePair ( ',' elementValuePair )* )
   6148             dbg.enterAlt(1);
   6149 
   6150             // src/com/google/doclava/parser/Java.g:730:9: elementValuePair ( ',' elementValuePair )*
   6151             {
   6152             dbg.location(730,9);
   6153             pushFollow(FOLLOW_elementValuePair_in_elementValuePairs3488);
   6154             elementValuePair();
   6155 
   6156             state._fsp--;
   6157             if (state.failed) return ;
   6158             dbg.location(731,9);
   6159             // src/com/google/doclava/parser/Java.g:731:9: ( ',' elementValuePair )*
   6160             try { dbg.enterSubRule(81);
   6161 
   6162             loop81:
   6163             do {
   6164                 int alt81=2;
   6165                 try { dbg.enterDecision(81, decisionCanBacktrack[81]);
   6166 
   6167                 int LA81_0 = input.LA(1);
   6168 
   6169                 if ( (LA81_0==COMMA) ) {
   6170                     alt81=1;
   6171                 }
   6172 
   6173 
   6174                 } finally {dbg.exitDecision(81);}
   6175 
   6176                 switch (alt81) {
   6177 		case 1 :
   6178 		    dbg.enterAlt(1);
   6179 
   6180 		    // src/com/google/doclava/parser/Java.g:731:10: ',' elementValuePair
   6181 		    {
   6182 		    dbg.location(731,10);
   6183 		    match(input,COMMA,FOLLOW_COMMA_in_elementValuePairs3499); if (state.failed) return ;
   6184 		    dbg.location(731,14);
   6185 		    pushFollow(FOLLOW_elementValuePair_in_elementValuePairs3501);
   6186 		    elementValuePair();
   6187 
   6188 		    state._fsp--;
   6189 		    if (state.failed) return ;
   6190 
   6191 		    }
   6192 		    break;
   6193 
   6194 		default :
   6195 		    break loop81;
   6196                 }
   6197             } while (true);
   6198             } finally {dbg.exitSubRule(81);}
   6199 
   6200 
   6201             }
   6202 
   6203         }
   6204         catch (RecognitionException re) {
   6205             reportError(re);
   6206             recover(input,re);
   6207         }
   6208         finally {
   6209             if ( state.backtracking>0 ) { memoize(input, 46, elementValuePairs_StartIndex); }
   6210         }
   6211         dbg.location(733, 5);
   6212 
   6213         }
   6214         finally {
   6215             dbg.exitRule(getGrammarFileName(), "elementValuePairs");
   6216             decRuleLevel();
   6217             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6218         }
   6219 
   6220         return ;
   6221     }
   6222     // $ANTLR end "elementValuePairs"
   6223 
   6224 
   6225     // $ANTLR start "elementValuePair"
   6226     // src/com/google/doclava/parser/Java.g:735:1: elementValuePair : IDENTIFIER '=' elementValue ;
   6227     public final void elementValuePair() throws RecognitionException {
   6228         int elementValuePair_StartIndex = input.index();
   6229         try { dbg.enterRule(getGrammarFileName(), "elementValuePair");
   6230         if ( getRuleLevel()==0 ) {dbg.commence();}
   6231         incRuleLevel();
   6232         dbg.location(735, 1);
   6233 
   6234         try {
   6235             if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return ; }
   6236             // src/com/google/doclava/parser/Java.g:736:5: ( IDENTIFIER '=' elementValue )
   6237             dbg.enterAlt(1);
   6238 
   6239             // src/com/google/doclava/parser/Java.g:736:9: IDENTIFIER '=' elementValue
   6240             {
   6241             dbg.location(736,9);
   6242             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_elementValuePair3531); if (state.failed) return ;
   6243             dbg.location(736,20);
   6244             match(input,EQ,FOLLOW_EQ_in_elementValuePair3533); if (state.failed) return ;
   6245             dbg.location(736,24);
   6246             pushFollow(FOLLOW_elementValue_in_elementValuePair3535);
   6247             elementValue();
   6248 
   6249             state._fsp--;
   6250             if (state.failed) return ;
   6251 
   6252             }
   6253 
   6254         }
   6255         catch (RecognitionException re) {
   6256             reportError(re);
   6257             recover(input,re);
   6258         }
   6259         finally {
   6260             if ( state.backtracking>0 ) { memoize(input, 47, elementValuePair_StartIndex); }
   6261         }
   6262         dbg.location(737, 5);
   6263 
   6264         }
   6265         finally {
   6266             dbg.exitRule(getGrammarFileName(), "elementValuePair");
   6267             decRuleLevel();
   6268             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6269         }
   6270 
   6271         return ;
   6272     }
   6273     // $ANTLR end "elementValuePair"
   6274 
   6275 
   6276     // $ANTLR start "elementValue"
   6277     // src/com/google/doclava/parser/Java.g:739:1: elementValue : ( conditionalExpression | annotation | elementValueArrayInitializer );
   6278     public final void elementValue() throws RecognitionException {
   6279         int elementValue_StartIndex = input.index();
   6280         try { dbg.enterRule(getGrammarFileName(), "elementValue");
   6281         if ( getRuleLevel()==0 ) {dbg.commence();}
   6282         incRuleLevel();
   6283         dbg.location(739, 1);
   6284 
   6285         try {
   6286             if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return ; }
   6287             // src/com/google/doclava/parser/Java.g:740:5: ( conditionalExpression | annotation | elementValueArrayInitializer )
   6288             int alt82=3;
   6289             try { dbg.enterDecision(82, decisionCanBacktrack[82]);
   6290 
   6291             switch ( input.LA(1) ) {
   6292             case IDENTIFIER:
   6293             case INTLITERAL:
   6294             case LONGLITERAL:
   6295             case FLOATLITERAL:
   6296             case DOUBLELITERAL:
   6297             case CHARLITERAL:
   6298             case STRINGLITERAL:
   6299             case TRUE:
   6300             case FALSE:
   6301             case NULL:
   6302             case BOOLEAN:
   6303             case BYTE:
   6304             case CHAR:
   6305             case DOUBLE:
   6306             case FLOAT:
   6307             case INT:
   6308             case LONG:
   6309             case NEW:
   6310             case SHORT:
   6311             case SUPER:
   6312             case THIS:
   6313             case VOID:
   6314             case LPAREN:
   6315             case BANG:
   6316             case TILDE:
   6317             case PLUSPLUS:
   6318             case SUBSUB:
   6319             case PLUS:
   6320             case SUB:
   6321                 {
   6322                 alt82=1;
   6323                 }
   6324                 break;
   6325             case MONKEYS_AT:
   6326                 {
   6327                 alt82=2;
   6328                 }
   6329                 break;
   6330             case LBRACE:
   6331                 {
   6332                 alt82=3;
   6333                 }
   6334                 break;
   6335             default:
   6336                 if (state.backtracking>0) {state.failed=true; return ;}
   6337                 NoViableAltException nvae =
   6338                     new NoViableAltException("", 82, 0, input);
   6339 
   6340                 dbg.recognitionException(nvae);
   6341                 throw nvae;
   6342             }
   6343 
   6344             } finally {dbg.exitDecision(82);}
   6345 
   6346             switch (alt82) {
   6347                 case 1 :
   6348                     dbg.enterAlt(1);
   6349 
   6350                     // src/com/google/doclava/parser/Java.g:740:9: conditionalExpression
   6351                     {
   6352                     dbg.location(740,9);
   6353                     pushFollow(FOLLOW_conditionalExpression_in_elementValue3554);
   6354                     conditionalExpression();
   6355 
   6356                     state._fsp--;
   6357                     if (state.failed) return ;
   6358 
   6359                     }
   6360                     break;
   6361                 case 2 :
   6362                     dbg.enterAlt(2);
   6363 
   6364                     // src/com/google/doclava/parser/Java.g:741:9: annotation
   6365                     {
   6366                     dbg.location(741,9);
   6367                     pushFollow(FOLLOW_annotation_in_elementValue3564);
   6368                     annotation();
   6369 
   6370                     state._fsp--;
   6371                     if (state.failed) return ;
   6372 
   6373                     }
   6374                     break;
   6375                 case 3 :
   6376                     dbg.enterAlt(3);
   6377 
   6378                     // src/com/google/doclava/parser/Java.g:742:9: elementValueArrayInitializer
   6379                     {
   6380                     dbg.location(742,9);
   6381                     pushFollow(FOLLOW_elementValueArrayInitializer_in_elementValue3574);
   6382                     elementValueArrayInitializer();
   6383 
   6384                     state._fsp--;
   6385                     if (state.failed) return ;
   6386 
   6387                     }
   6388                     break;
   6389 
   6390             }
   6391         }
   6392         catch (RecognitionException re) {
   6393             reportError(re);
   6394             recover(input,re);
   6395         }
   6396         finally {
   6397             if ( state.backtracking>0 ) { memoize(input, 48, elementValue_StartIndex); }
   6398         }
   6399         dbg.location(743, 5);
   6400 
   6401         }
   6402         finally {
   6403             dbg.exitRule(getGrammarFileName(), "elementValue");
   6404             decRuleLevel();
   6405             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6406         }
   6407 
   6408         return ;
   6409     }
   6410     // $ANTLR end "elementValue"
   6411 
   6412 
   6413     // $ANTLR start "elementValueArrayInitializer"
   6414     // src/com/google/doclava/parser/Java.g:745:1: elementValueArrayInitializer : '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' ;
   6415     public final void elementValueArrayInitializer() throws RecognitionException {
   6416         int elementValueArrayInitializer_StartIndex = input.index();
   6417         try { dbg.enterRule(getGrammarFileName(), "elementValueArrayInitializer");
   6418         if ( getRuleLevel()==0 ) {dbg.commence();}
   6419         incRuleLevel();
   6420         dbg.location(745, 1);
   6421 
   6422         try {
   6423             if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return ; }
   6424             // src/com/google/doclava/parser/Java.g:746:5: ( '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' )
   6425             dbg.enterAlt(1);
   6426 
   6427             // src/com/google/doclava/parser/Java.g:746:9: '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}'
   6428             {
   6429             dbg.location(746,9);
   6430             match(input,LBRACE,FOLLOW_LBRACE_in_elementValueArrayInitializer3593); if (state.failed) return ;
   6431             dbg.location(747,9);
   6432             // src/com/google/doclava/parser/Java.g:747:9: ( elementValue ( ',' elementValue )* )?
   6433             int alt84=2;
   6434             try { dbg.enterSubRule(84);
   6435             try { dbg.enterDecision(84, decisionCanBacktrack[84]);
   6436 
   6437             int LA84_0 = input.LA(1);
   6438 
   6439             if ( ((LA84_0>=IDENTIFIER && LA84_0<=NULL)||LA84_0==BOOLEAN||LA84_0==BYTE||LA84_0==CHAR||LA84_0==DOUBLE||LA84_0==FLOAT||LA84_0==INT||LA84_0==LONG||LA84_0==NEW||LA84_0==SHORT||LA84_0==SUPER||LA84_0==THIS||LA84_0==VOID||LA84_0==LPAREN||LA84_0==LBRACE||(LA84_0>=BANG && LA84_0<=TILDE)||(LA84_0>=PLUSPLUS && LA84_0<=SUB)||LA84_0==MONKEYS_AT) ) {
   6440                 alt84=1;
   6441             }
   6442             } finally {dbg.exitDecision(84);}
   6443 
   6444             switch (alt84) {
   6445                 case 1 :
   6446                     dbg.enterAlt(1);
   6447 
   6448                     // src/com/google/doclava/parser/Java.g:747:10: elementValue ( ',' elementValue )*
   6449                     {
   6450                     dbg.location(747,10);
   6451                     pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer3604);
   6452                     elementValue();
   6453 
   6454                     state._fsp--;
   6455                     if (state.failed) return ;
   6456                     dbg.location(748,13);
   6457                     // src/com/google/doclava/parser/Java.g:748:13: ( ',' elementValue )*
   6458                     try { dbg.enterSubRule(83);
   6459 
   6460                     loop83:
   6461                     do {
   6462                         int alt83=2;
   6463                         try { dbg.enterDecision(83, decisionCanBacktrack[83]);
   6464 
   6465                         int LA83_0 = input.LA(1);
   6466 
   6467                         if ( (LA83_0==COMMA) ) {
   6468                             int LA83_1 = input.LA(2);
   6469 
   6470                             if ( ((LA83_1>=IDENTIFIER && LA83_1<=NULL)||LA83_1==BOOLEAN||LA83_1==BYTE||LA83_1==CHAR||LA83_1==DOUBLE||LA83_1==FLOAT||LA83_1==INT||LA83_1==LONG||LA83_1==NEW||LA83_1==SHORT||LA83_1==SUPER||LA83_1==THIS||LA83_1==VOID||LA83_1==LPAREN||LA83_1==LBRACE||(LA83_1>=BANG && LA83_1<=TILDE)||(LA83_1>=PLUSPLUS && LA83_1<=SUB)||LA83_1==MONKEYS_AT) ) {
   6471                                 alt83=1;
   6472                             }
   6473 
   6474 
   6475                         }
   6476 
   6477 
   6478                         } finally {dbg.exitDecision(83);}
   6479 
   6480                         switch (alt83) {
   6481 			case 1 :
   6482 			    dbg.enterAlt(1);
   6483 
   6484 			    // src/com/google/doclava/parser/Java.g:748:14: ',' elementValue
   6485 			    {
   6486 			    dbg.location(748,14);
   6487 			    match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer3619); if (state.failed) return ;
   6488 			    dbg.location(748,18);
   6489 			    pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer3621);
   6490 			    elementValue();
   6491 
   6492 			    state._fsp--;
   6493 			    if (state.failed) return ;
   6494 
   6495 			    }
   6496 			    break;
   6497 
   6498 			default :
   6499 			    break loop83;
   6500                         }
   6501                     } while (true);
   6502                     } finally {dbg.exitSubRule(83);}
   6503 
   6504 
   6505                     }
   6506                     break;
   6507 
   6508             }
   6509             } finally {dbg.exitSubRule(84);}
   6510 
   6511             dbg.location(750,12);
   6512             // src/com/google/doclava/parser/Java.g:750:12: ( ',' )?
   6513             int alt85=2;
   6514             try { dbg.enterSubRule(85);
   6515             try { dbg.enterDecision(85, decisionCanBacktrack[85]);
   6516 
   6517             int LA85_0 = input.LA(1);
   6518 
   6519             if ( (LA85_0==COMMA) ) {
   6520                 alt85=1;
   6521             }
   6522             } finally {dbg.exitDecision(85);}
   6523 
   6524             switch (alt85) {
   6525                 case 1 :
   6526                     dbg.enterAlt(1);
   6527 
   6528                     // src/com/google/doclava/parser/Java.g:750:13: ','
   6529                     {
   6530                     dbg.location(750,13);
   6531                     match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer3650); if (state.failed) return ;
   6532 
   6533                     }
   6534                     break;
   6535 
   6536             }
   6537             } finally {dbg.exitSubRule(85);}
   6538 
   6539             dbg.location(750,19);
   6540             match(input,RBRACE,FOLLOW_RBRACE_in_elementValueArrayInitializer3654); if (state.failed) return ;
   6541 
   6542             }
   6543 
   6544         }
   6545         catch (RecognitionException re) {
   6546             reportError(re);
   6547             recover(input,re);
   6548         }
   6549         finally {
   6550             if ( state.backtracking>0 ) { memoize(input, 49, elementValueArrayInitializer_StartIndex); }
   6551         }
   6552         dbg.location(751, 5);
   6553 
   6554         }
   6555         finally {
   6556             dbg.exitRule(getGrammarFileName(), "elementValueArrayInitializer");
   6557             decRuleLevel();
   6558             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6559         }
   6560 
   6561         return ;
   6562     }
   6563     // $ANTLR end "elementValueArrayInitializer"
   6564 
   6565 
   6566     // $ANTLR start "annotationTypeDeclaration"
   6567     // src/com/google/doclava/parser/Java.g:754:1: annotationTypeDeclaration : modifiers '@' 'interface' IDENTIFIER annotationTypeBody ;
   6568     public final void annotationTypeDeclaration() throws RecognitionException {
   6569         int annotationTypeDeclaration_StartIndex = input.index();
   6570         try { dbg.enterRule(getGrammarFileName(), "annotationTypeDeclaration");
   6571         if ( getRuleLevel()==0 ) {dbg.commence();}
   6572         incRuleLevel();
   6573         dbg.location(754, 1);
   6574 
   6575         try {
   6576             if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return ; }
   6577             // src/com/google/doclava/parser/Java.g:758:5: ( modifiers '@' 'interface' IDENTIFIER annotationTypeBody )
   6578             dbg.enterAlt(1);
   6579 
   6580             // src/com/google/doclava/parser/Java.g:758:9: modifiers '@' 'interface' IDENTIFIER annotationTypeBody
   6581             {
   6582             dbg.location(758,9);
   6583             pushFollow(FOLLOW_modifiers_in_annotationTypeDeclaration3676);
   6584             modifiers();
   6585 
   6586             state._fsp--;
   6587             if (state.failed) return ;
   6588             dbg.location(758,19);
   6589             match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration3678); if (state.failed) return ;
   6590             dbg.location(759,9);
   6591             match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationTypeDeclaration3688); if (state.failed) return ;
   6592             dbg.location(760,9);
   6593             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationTypeDeclaration3698); if (state.failed) return ;
   6594             dbg.location(761,9);
   6595             pushFollow(FOLLOW_annotationTypeBody_in_annotationTypeDeclaration3708);
   6596             annotationTypeBody();
   6597 
   6598             state._fsp--;
   6599             if (state.failed) return ;
   6600 
   6601             }
   6602 
   6603         }
   6604         catch (RecognitionException re) {
   6605             reportError(re);
   6606             recover(input,re);
   6607         }
   6608         finally {
   6609             if ( state.backtracking>0 ) { memoize(input, 50, annotationTypeDeclaration_StartIndex); }
   6610         }
   6611         dbg.location(762, 5);
   6612 
   6613         }
   6614         finally {
   6615             dbg.exitRule(getGrammarFileName(), "annotationTypeDeclaration");
   6616             decRuleLevel();
   6617             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6618         }
   6619 
   6620         return ;
   6621     }
   6622     // $ANTLR end "annotationTypeDeclaration"
   6623 
   6624 
   6625     // $ANTLR start "annotationTypeBody"
   6626     // src/com/google/doclava/parser/Java.g:765:1: annotationTypeBody : '{' ( annotationTypeElementDeclaration )* '}' ;
   6627     public final void annotationTypeBody() throws RecognitionException {
   6628         int annotationTypeBody_StartIndex = input.index();
   6629         try { dbg.enterRule(getGrammarFileName(), "annotationTypeBody");
   6630         if ( getRuleLevel()==0 ) {dbg.commence();}
   6631         incRuleLevel();
   6632         dbg.location(765, 1);
   6633 
   6634         try {
   6635             if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return ; }
   6636             // src/com/google/doclava/parser/Java.g:766:5: ( '{' ( annotationTypeElementDeclaration )* '}' )
   6637             dbg.enterAlt(1);
   6638 
   6639             // src/com/google/doclava/parser/Java.g:766:9: '{' ( annotationTypeElementDeclaration )* '}'
   6640             {
   6641             dbg.location(766,9);
   6642             match(input,LBRACE,FOLLOW_LBRACE_in_annotationTypeBody3728); if (state.failed) return ;
   6643             dbg.location(767,9);
   6644             // src/com/google/doclava/parser/Java.g:767:9: ( annotationTypeElementDeclaration )*
   6645             try { dbg.enterSubRule(86);
   6646 
   6647             loop86:
   6648             do {
   6649                 int alt86=2;
   6650                 try { dbg.enterDecision(86, decisionCanBacktrack[86]);
   6651 
   6652                 int LA86_0 = input.LA(1);
   6653 
   6654                 if ( (LA86_0==IDENTIFIER||LA86_0==ABSTRACT||LA86_0==BOOLEAN||LA86_0==BYTE||(LA86_0>=CHAR && LA86_0<=CLASS)||LA86_0==DOUBLE||LA86_0==ENUM||LA86_0==FINAL||LA86_0==FLOAT||(LA86_0>=INT && LA86_0<=NATIVE)||(LA86_0>=PRIVATE && LA86_0<=PUBLIC)||(LA86_0>=SHORT && LA86_0<=STRICTFP)||LA86_0==SYNCHRONIZED||LA86_0==TRANSIENT||(LA86_0>=VOID && LA86_0<=VOLATILE)||LA86_0==SEMI||LA86_0==MONKEYS_AT||LA86_0==LT) ) {
   6655                     alt86=1;
   6656                 }
   6657 
   6658 
   6659                 } finally {dbg.exitDecision(86);}
   6660 
   6661                 switch (alt86) {
   6662 		case 1 :
   6663 		    dbg.enterAlt(1);
   6664 
   6665 		    // src/com/google/doclava/parser/Java.g:767:10: annotationTypeElementDeclaration
   6666 		    {
   6667 		    dbg.location(767,10);
   6668 		    pushFollow(FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody3739);
   6669 		    annotationTypeElementDeclaration();
   6670 
   6671 		    state._fsp--;
   6672 		    if (state.failed) return ;
   6673 
   6674 		    }
   6675 		    break;
   6676 
   6677 		default :
   6678 		    break loop86;
   6679                 }
   6680             } while (true);
   6681             } finally {dbg.exitSubRule(86);}
   6682 
   6683             dbg.location(769,9);
   6684             match(input,RBRACE,FOLLOW_RBRACE_in_annotationTypeBody3760); if (state.failed) return ;
   6685 
   6686             }
   6687 
   6688         }
   6689         catch (RecognitionException re) {
   6690             reportError(re);
   6691             recover(input,re);
   6692         }
   6693         finally {
   6694             if ( state.backtracking>0 ) { memoize(input, 51, annotationTypeBody_StartIndex); }
   6695         }
   6696         dbg.location(770, 5);
   6697 
   6698         }
   6699         finally {
   6700             dbg.exitRule(getGrammarFileName(), "annotationTypeBody");
   6701             decRuleLevel();
   6702             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6703         }
   6704 
   6705         return ;
   6706     }
   6707     // $ANTLR end "annotationTypeBody"
   6708 
   6709 
   6710     // $ANTLR start "annotationTypeElementDeclaration"
   6711     // src/com/google/doclava/parser/Java.g:772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' );
   6712     public final void annotationTypeElementDeclaration() throws RecognitionException {
   6713         int annotationTypeElementDeclaration_StartIndex = input.index();
   6714         try { dbg.enterRule(getGrammarFileName(), "annotationTypeElementDeclaration");
   6715         if ( getRuleLevel()==0 ) {dbg.commence();}
   6716         incRuleLevel();
   6717         dbg.location(772, 1);
   6718 
   6719         try {
   6720             if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return ; }
   6721             // src/com/google/doclava/parser/Java.g:776:5: ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' )
   6722             int alt87=7;
   6723             try { dbg.enterDecision(87, decisionCanBacktrack[87]);
   6724 
   6725             try {
   6726                 isCyclicDecision = true;
   6727                 alt87 = dfa87.predict(input);
   6728             }
   6729             catch (NoViableAltException nvae) {
   6730                 dbg.recognitionException(nvae);
   6731                 throw nvae;
   6732             }
   6733             } finally {dbg.exitDecision(87);}
   6734 
   6735             switch (alt87) {
   6736                 case 1 :
   6737                     dbg.enterAlt(1);
   6738 
   6739                     // src/com/google/doclava/parser/Java.g:776:9: annotationMethodDeclaration
   6740                     {
   6741                     dbg.location(776,9);
   6742                     pushFollow(FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration3781);
   6743                     annotationMethodDeclaration();
   6744 
   6745                     state._fsp--;
   6746                     if (state.failed) return ;
   6747 
   6748                     }
   6749                     break;
   6750                 case 2 :
   6751                     dbg.enterAlt(2);
   6752 
   6753                     // src/com/google/doclava/parser/Java.g:777:9: interfaceFieldDeclaration
   6754                     {
   6755                     dbg.location(777,9);
   6756                     pushFollow(FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration3791);
   6757                     interfaceFieldDeclaration();
   6758 
   6759                     state._fsp--;
   6760                     if (state.failed) return ;
   6761 
   6762                     }
   6763                     break;
   6764                 case 3 :
   6765                     dbg.enterAlt(3);
   6766 
   6767                     // src/com/google/doclava/parser/Java.g:778:9: normalClassDeclaration
   6768                     {
   6769                     dbg.location(778,9);
   6770                     pushFollow(FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration3801);
   6771                     normalClassDeclaration();
   6772 
   6773                     state._fsp--;
   6774                     if (state.failed) return ;
   6775 
   6776                     }
   6777                     break;
   6778                 case 4 :
   6779                     dbg.enterAlt(4);
   6780 
   6781                     // src/com/google/doclava/parser/Java.g:779:9: normalInterfaceDeclaration
   6782                     {
   6783                     dbg.location(779,9);
   6784                     pushFollow(FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration3811);
   6785                     normalInterfaceDeclaration();
   6786 
   6787                     state._fsp--;
   6788                     if (state.failed) return ;
   6789 
   6790                     }
   6791                     break;
   6792                 case 5 :
   6793                     dbg.enterAlt(5);
   6794 
   6795                     // src/com/google/doclava/parser/Java.g:780:9: enumDeclaration
   6796                     {
   6797                     dbg.location(780,9);
   6798                     pushFollow(FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration3821);
   6799                     enumDeclaration();
   6800 
   6801                     state._fsp--;
   6802                     if (state.failed) return ;
   6803 
   6804                     }
   6805                     break;
   6806                 case 6 :
   6807                     dbg.enterAlt(6);
   6808 
   6809                     // src/com/google/doclava/parser/Java.g:781:9: annotationTypeDeclaration
   6810                     {
   6811                     dbg.location(781,9);
   6812                     pushFollow(FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration3831);
   6813                     annotationTypeDeclaration();
   6814 
   6815                     state._fsp--;
   6816                     if (state.failed) return ;
   6817 
   6818                     }
   6819                     break;
   6820                 case 7 :
   6821                     dbg.enterAlt(7);
   6822 
   6823                     // src/com/google/doclava/parser/Java.g:782:9: ';'
   6824                     {
   6825                     dbg.location(782,9);
   6826                     match(input,SEMI,FOLLOW_SEMI_in_annotationTypeElementDeclaration3841); if (state.failed) return ;
   6827 
   6828                     }
   6829                     break;
   6830 
   6831             }
   6832         }
   6833         catch (RecognitionException re) {
   6834             reportError(re);
   6835             recover(input,re);
   6836         }
   6837         finally {
   6838             if ( state.backtracking>0 ) { memoize(input, 52, annotationTypeElementDeclaration_StartIndex); }
   6839         }
   6840         dbg.location(783, 5);
   6841 
   6842         }
   6843         finally {
   6844             dbg.exitRule(getGrammarFileName(), "annotationTypeElementDeclaration");
   6845             decRuleLevel();
   6846             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6847         }
   6848 
   6849         return ;
   6850     }
   6851     // $ANTLR end "annotationTypeElementDeclaration"
   6852 
   6853 
   6854     // $ANTLR start "annotationMethodDeclaration"
   6855     // src/com/google/doclava/parser/Java.g:785:1: annotationMethodDeclaration : modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' ;
   6856     public final void annotationMethodDeclaration() throws RecognitionException {
   6857         int annotationMethodDeclaration_StartIndex = input.index();
   6858         try { dbg.enterRule(getGrammarFileName(), "annotationMethodDeclaration");
   6859         if ( getRuleLevel()==0 ) {dbg.commence();}
   6860         incRuleLevel();
   6861         dbg.location(785, 1);
   6862 
   6863         try {
   6864             if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return ; }
   6865             // src/com/google/doclava/parser/Java.g:786:5: ( modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' )
   6866             dbg.enterAlt(1);
   6867 
   6868             // src/com/google/doclava/parser/Java.g:786:9: modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';'
   6869             {
   6870             dbg.location(786,9);
   6871             pushFollow(FOLLOW_modifiers_in_annotationMethodDeclaration3860);
   6872             modifiers();
   6873 
   6874             state._fsp--;
   6875             if (state.failed) return ;
   6876             dbg.location(786,19);
   6877             pushFollow(FOLLOW_type_in_annotationMethodDeclaration3862);
   6878             type();
   6879 
   6880             state._fsp--;
   6881             if (state.failed) return ;
   6882             dbg.location(786,24);
   6883             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationMethodDeclaration3864); if (state.failed) return ;
   6884             dbg.location(787,9);
   6885             match(input,LPAREN,FOLLOW_LPAREN_in_annotationMethodDeclaration3874); if (state.failed) return ;
   6886             dbg.location(787,13);
   6887             match(input,RPAREN,FOLLOW_RPAREN_in_annotationMethodDeclaration3876); if (state.failed) return ;
   6888             dbg.location(787,17);
   6889             // src/com/google/doclava/parser/Java.g:787:17: ( 'default' elementValue )?
   6890             int alt88=2;
   6891             try { dbg.enterSubRule(88);
   6892             try { dbg.enterDecision(88, decisionCanBacktrack[88]);
   6893 
   6894             int LA88_0 = input.LA(1);
   6895 
   6896             if ( (LA88_0==DEFAULT) ) {
   6897                 alt88=1;
   6898             }
   6899             } finally {dbg.exitDecision(88);}
   6900 
   6901             switch (alt88) {
   6902                 case 1 :
   6903                     dbg.enterAlt(1);
   6904 
   6905                     // src/com/google/doclava/parser/Java.g:787:18: 'default' elementValue
   6906                     {
   6907                     dbg.location(787,18);
   6908                     match(input,DEFAULT,FOLLOW_DEFAULT_in_annotationMethodDeclaration3879); if (state.failed) return ;
   6909                     dbg.location(787,28);
   6910                     pushFollow(FOLLOW_elementValue_in_annotationMethodDeclaration3881);
   6911                     elementValue();
   6912 
   6913                     state._fsp--;
   6914                     if (state.failed) return ;
   6915 
   6916                     }
   6917                     break;
   6918 
   6919             }
   6920             } finally {dbg.exitSubRule(88);}
   6921 
   6922             dbg.location(789,9);
   6923             match(input,SEMI,FOLLOW_SEMI_in_annotationMethodDeclaration3910); if (state.failed) return ;
   6924 
   6925             }
   6926 
   6927         }
   6928         catch (RecognitionException re) {
   6929             reportError(re);
   6930             recover(input,re);
   6931         }
   6932         finally {
   6933             if ( state.backtracking>0 ) { memoize(input, 53, annotationMethodDeclaration_StartIndex); }
   6934         }
   6935         dbg.location(790, 9);
   6936 
   6937         }
   6938         finally {
   6939             dbg.exitRule(getGrammarFileName(), "annotationMethodDeclaration");
   6940             decRuleLevel();
   6941             if ( getRuleLevel()==0 ) {dbg.terminate();}
   6942         }
   6943 
   6944         return ;
   6945     }
   6946     // $ANTLR end "annotationMethodDeclaration"
   6947 
   6948 
   6949     // $ANTLR start "block"
   6950     // src/com/google/doclava/parser/Java.g:792:1: block : '{' ( blockStatement )* '}' ;
   6951     public final void block() throws RecognitionException {
   6952         int block_StartIndex = input.index();
   6953         try { dbg.enterRule(getGrammarFileName(), "block");
   6954         if ( getRuleLevel()==0 ) {dbg.commence();}
   6955         incRuleLevel();
   6956         dbg.location(792, 1);
   6957 
   6958         try {
   6959             if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return ; }
   6960             // src/com/google/doclava/parser/Java.g:793:5: ( '{' ( blockStatement )* '}' )
   6961             dbg.enterAlt(1);
   6962 
   6963             // src/com/google/doclava/parser/Java.g:793:9: '{' ( blockStatement )* '}'
   6964             {
   6965             dbg.location(793,9);
   6966             match(input,LBRACE,FOLLOW_LBRACE_in_block3933); if (state.failed) return ;
   6967             dbg.location(794,9);
   6968             // src/com/google/doclava/parser/Java.g:794:9: ( blockStatement )*
   6969             try { dbg.enterSubRule(89);
   6970 
   6971             loop89:
   6972             do {
   6973                 int alt89=2;
   6974                 try { dbg.enterDecision(89, decisionCanBacktrack[89]);
   6975 
   6976                 int LA89_0 = input.LA(1);
   6977 
   6978                 if ( ((LA89_0>=IDENTIFIER && LA89_0<=NULL)||(LA89_0>=ABSTRACT && LA89_0<=BYTE)||(LA89_0>=CHAR && LA89_0<=CLASS)||LA89_0==CONTINUE||(LA89_0>=DO && LA89_0<=DOUBLE)||LA89_0==ENUM||LA89_0==FINAL||(LA89_0>=FLOAT && LA89_0<=FOR)||LA89_0==IF||(LA89_0>=INT && LA89_0<=NEW)||(LA89_0>=PRIVATE && LA89_0<=THROW)||(LA89_0>=TRANSIENT && LA89_0<=LPAREN)||LA89_0==LBRACE||LA89_0==SEMI||(LA89_0>=BANG && LA89_0<=TILDE)||(LA89_0>=PLUSPLUS && LA89_0<=SUB)||LA89_0==MONKEYS_AT||LA89_0==LT) ) {
   6979                     alt89=1;
   6980                 }
   6981 
   6982 
   6983                 } finally {dbg.exitDecision(89);}
   6984 
   6985                 switch (alt89) {
   6986 		case 1 :
   6987 		    dbg.enterAlt(1);
   6988 
   6989 		    // src/com/google/doclava/parser/Java.g:794:10: blockStatement
   6990 		    {
   6991 		    dbg.location(794,10);
   6992 		    pushFollow(FOLLOW_blockStatement_in_block3944);
   6993 		    blockStatement();
   6994 
   6995 		    state._fsp--;
   6996 		    if (state.failed) return ;
   6997 
   6998 		    }
   6999 		    break;
   7000 
   7001 		default :
   7002 		    break loop89;
   7003                 }
   7004             } while (true);
   7005             } finally {dbg.exitSubRule(89);}
   7006 
   7007             dbg.location(796,9);
   7008             match(input,RBRACE,FOLLOW_RBRACE_in_block3965); if (state.failed) return ;
   7009 
   7010             }
   7011 
   7012         }
   7013         catch (RecognitionException re) {
   7014             reportError(re);
   7015             recover(input,re);
   7016         }
   7017         finally {
   7018             if ( state.backtracking>0 ) { memoize(input, 54, block_StartIndex); }
   7019         }
   7020         dbg.location(797, 5);
   7021 
   7022         }
   7023         finally {
   7024             dbg.exitRule(getGrammarFileName(), "block");
   7025             decRuleLevel();
   7026             if ( getRuleLevel()==0 ) {dbg.terminate();}
   7027         }
   7028 
   7029         return ;
   7030     }
   7031     // $ANTLR end "block"
   7032 
   7033 
   7034     // $ANTLR start "blockStatement"
   7035     // src/com/google/doclava/parser/Java.g:823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );
   7036     public final void blockStatement() throws RecognitionException {
   7037         int blockStatement_StartIndex = input.index();
   7038         try { dbg.enterRule(getGrammarFileName(), "blockStatement");
   7039         if ( getRuleLevel()==0 ) {dbg.commence();}
   7040         incRuleLevel();
   7041         dbg.location(823, 1);
   7042 
   7043         try {
   7044             if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return ; }
   7045             // src/com/google/doclava/parser/Java.g:824:5: ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement )
   7046             int alt90=3;
   7047             try { dbg.enterDecision(90, decisionCanBacktrack[90]);
   7048 
   7049             try {
   7050                 isCyclicDecision = true;
   7051                 alt90 = dfa90.predict(input);
   7052             }
   7053             catch (NoViableAltException nvae) {
   7054                 dbg.recognitionException(nvae);
   7055                 throw nvae;
   7056             }
   7057             } finally {dbg.exitDecision(90);}
   7058 
   7059             switch (alt90) {
   7060                 case 1 :
   7061                     dbg.enterAlt(1);
   7062 
   7063                     // src/com/google/doclava/parser/Java.g:824:9: localVariableDeclarationStatement
   7064                     {
   7065                     dbg.location(824,9);
   7066                     pushFollow(FOLLOW_localVariableDeclarationStatement_in_blockStatement3986);
   7067                     localVariableDeclarationStatement();
   7068 
   7069                     state._fsp--;
   7070                     if (state.failed) return ;
   7071 
   7072                     }
   7073                     break;
   7074                 case 2 :
   7075                     dbg.enterAlt(2);
   7076 
   7077                     // src/com/google/doclava/parser/Java.g:825:9: classOrInterfaceDeclaration
   7078                     {
   7079                     dbg.location(825,9);
   7080                     pushFollow(FOLLOW_classOrInterfaceDeclaration_in_blockStatement3996);
   7081                     classOrInterfaceDeclaration();
   7082 
   7083                     state._fsp--;
   7084                     if (state.failed) return ;
   7085 
   7086                     }
   7087                     break;
   7088                 case 3 :
   7089                     dbg.enterAlt(3);
   7090 
   7091                     // src/com/google/doclava/parser/Java.g:826:9: statement
   7092                     {
   7093                     dbg.location(826,9);
   7094                     pushFollow(FOLLOW_statement_in_blockStatement4006);
   7095                     statement();
   7096 
   7097                     state._fsp--;
   7098                     if (state.failed) return ;
   7099 
   7100                     }
   7101                     break;
   7102 
   7103             }
   7104         }
   7105         catch (RecognitionException re) {
   7106             reportError(re);
   7107             recover(input,re);
   7108         }
   7109         finally {
   7110             if ( state.backtracking>0 ) { memoize(input, 55, blockStatement_StartIndex); }
   7111         }
   7112         dbg.location(827, 5);
   7113 
   7114         }
   7115         finally {
   7116             dbg.exitRule(getGrammarFileName(), "blockStatement");
   7117             decRuleLevel();
   7118             if ( getRuleLevel()==0 ) {dbg.terminate();}
   7119         }
   7120 
   7121         return ;
   7122     }
   7123     // $ANTLR end "blockStatement"
   7124 
   7125 
   7126     // $ANTLR start "localVariableDeclarationStatement"
   7127     // src/com/google/doclava/parser/Java.g:830:1: localVariableDeclarationStatement : localVariableDeclaration ';' ;
   7128     public final void localVariableDeclarationStatement() throws RecognitionException {
   7129         int localVariableDeclarationStatement_StartIndex = input.index();
   7130         try { dbg.enterRule(getGrammarFileName(), "localVariableDeclarationStatement");
   7131         if ( getRuleLevel()==0 ) {dbg.commence();}
   7132         incRuleLevel();
   7133         dbg.location(830, 1);
   7134 
   7135         try {
   7136             if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return ; }
   7137             // src/com/google/doclava/parser/Java.g:831:5: ( localVariableDeclaration ';' )
   7138             dbg.enterAlt(1);
   7139 
   7140             // src/com/google/doclava/parser/Java.g:831:9: localVariableDeclaration ';'
   7141             {
   7142             dbg.location(831,9);
   7143             pushFollow(FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4026);
   7144             localVariableDeclaration();
   7145 
   7146             state._fsp--;
   7147             if (state.failed) return ;
   7148             dbg.location(832,9);
   7149             match(input,SEMI,FOLLOW_SEMI_in_localVariableDeclarationStatement4036); if (state.failed) return ;
   7150 
   7151             }
   7152 
   7153         }
   7154         catch (RecognitionException re) {
   7155             reportError(re);
   7156             recover(input,re);
   7157         }
   7158         finally {
   7159             if ( state.backtracking>0 ) { memoize(input, 56, localVariableDeclarationStatement_StartIndex); }
   7160         }
   7161         dbg.location(833, 5);
   7162 
   7163         }
   7164         finally {
   7165             dbg.exitRule(getGrammarFileName(), "localVariableDeclarationStatement");
   7166             decRuleLevel();
   7167             if ( getRuleLevel()==0 ) {dbg.terminate();}
   7168         }
   7169 
   7170         return ;
   7171     }
   7172     // $ANTLR end "localVariableDeclarationStatement"
   7173 
   7174 
   7175     // $ANTLR start "localVariableDeclaration"
   7176     // src/com/google/doclava/parser/Java.g:835:1: localVariableDeclaration : variableModifiers type variableDeclarator ( ',' variableDeclarator )* ;
   7177     public final void localVariableDeclaration() throws RecognitionException {
   7178         int localVariableDeclaration_StartIndex = input.index();
   7179         try { dbg.enterRule(getGrammarFileName(), "localVariableDeclaration");
   7180         if ( getRuleLevel()==0 ) {dbg.commence();}
   7181         incRuleLevel();
   7182         dbg.location(835, 1);
   7183 
   7184         try {
   7185             if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return ; }
   7186             // src/com/google/doclava/parser/Java.g:836:5: ( variableModifiers type variableDeclarator ( ',' variableDeclarator )* )
   7187             dbg.enterAlt(1);
   7188 
   7189             // src/com/google/doclava/parser/Java.g:836:9: variableModifiers type variableDeclarator ( ',' variableDeclarator )*
   7190             {
   7191             dbg.location(836,9);
   7192             pushFollow(FOLLOW_variableModifiers_in_localVariableDeclaration4055);
   7193             variableModifiers();
   7194 
   7195             state._fsp--;
   7196             if (state.failed) return ;
   7197             dbg.location(836,27);
   7198             pushFollow(FOLLOW_type_in_localVariableDeclaration4057);
   7199             type();
   7200 
   7201             state._fsp--;
   7202             if (state.failed) return ;
   7203             dbg.location(837,9);
   7204             pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4067);
   7205             variableDeclarator();
   7206 
   7207             state._fsp--;
   7208             if (state.failed) return ;
   7209             dbg.location(838,9);
   7210             // src/com/google/doclava/parser/Java.g:838:9: ( ',' variableDeclarator )*
   7211             try { dbg.enterSubRule(91);
   7212 
   7213             loop91:
   7214             do {
   7215                 int alt91=2;
   7216                 try { dbg.enterDecision(91, decisionCanBacktrack[91]);
   7217 
   7218                 int LA91_0 = input.LA(1);
   7219 
   7220                 if ( (LA91_0==COMMA) ) {
   7221                     alt91=1;
   7222                 }
   7223 
   7224 
   7225                 } finally {dbg.exitDecision(91);}
   7226 
   7227                 switch (alt91) {
   7228 		case 1 :
   7229 		    dbg.enterAlt(1);
   7230 
   7231 		    // src/com/google/doclava/parser/Java.g:838:10: ',' variableDeclarator
   7232 		    {
   7233 		    dbg.location(838,10);
   7234 		    match(input,COMMA,FOLLOW_COMMA_in_localVariableDeclaration4078); if (state.failed) return ;
   7235 		    dbg.location(838,14);
   7236 		    pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4080);
   7237 		    variableDeclarator();
   7238 
   7239 		    state._fsp--;
   7240 		    if (state.failed) return ;
   7241 
   7242 		    }
   7243 		    break;
   7244 
   7245 		default :
   7246 		    break loop91;
   7247                 }
   7248             } while (true);
   7249             } finally {dbg.exitSubRule(91);}
   7250 
   7251 
   7252             }
   7253 
   7254         }
   7255         catch (RecognitionException re) {
   7256             reportError(re);
   7257             recover(input,re);
   7258         }
   7259         finally {
   7260             if ( state.backtracking>0 ) { memoize(input, 57, localVariableDeclaration_StartIndex); }
   7261         }
   7262         dbg.location(840, 5);
   7263 
   7264         }
   7265         finally {
   7266             dbg.exitRule(getGrammarFileName(), "localVariableDeclaration");
   7267             decRuleLevel();
   7268             if ( getRuleLevel()==0 ) {dbg.terminate();}
   7269         }
   7270 
   7271         return ;
   7272     }
   7273     // $ANTLR end "localVariableDeclaration"
   7274 
   7275 
   7276     // $ANTLR start "statement"
   7277     // src/com/google/doclava/parser/Java.g:842:1: statement : ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' );
   7278     public final void statement() throws RecognitionException {
   7279         int statement_StartIndex = input.index();
   7280         try { dbg.enterRule(getGrammarFileName(), "statement");
   7281         if ( getRuleLevel()==0 ) {dbg.commence();}
   7282         incRuleLevel();
   7283         dbg.location(842, 1);
   7284 
   7285         try {
   7286             if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return ; }
   7287             // src/com/google/doclava/parser/Java.g:843:5: ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' )
   7288             int alt98=17;
   7289             try { dbg.enterDecision(98, decisionCanBacktrack[98]);
   7290 
   7291             try {
   7292                 isCyclicDecision = true;
   7293                 alt98 = dfa98.predict(input);
   7294             }
   7295             catch (NoViableAltException nvae) {
   7296                 dbg.recognitionException(nvae);
   7297                 throw nvae;
   7298             }
   7299             } finally {dbg.exitDecision(98);}
   7300 
   7301             switch (alt98) {
   7302                 case 1 :
   7303                     dbg.enterAlt(1);
   7304 
   7305                     // src/com/google/doclava/parser/Java.g:843:9: block
   7306                     {
   7307                     dbg.location(843,9);
   7308                     pushFollow(FOLLOW_block_in_statement4110);
   7309                     block();
   7310 
   7311                     state._fsp--;
   7312                     if (state.failed) return ;
   7313 
   7314                     }
   7315                     break;
   7316                 case 2 :
   7317                     dbg.enterAlt(2);
   7318 
   7319                     // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) expression ( ':' expression )? ';'
   7320                     {
   7321                     dbg.location(845,9);
   7322                     // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' )
   7323                     dbg.enterAlt(1);
   7324 
   7325                     // src/com/google/doclava/parser/Java.g:845:10: 'assert'
   7326                     {
   7327                     dbg.location(845,10);
   7328                     match(input,ASSERT,FOLLOW_ASSERT_in_statement4122); if (state.failed) return ;
   7329 
   7330                     }
   7331 
   7332                     dbg.location(847,9);
   7333                     pushFollow(FOLLOW_expression_in_statement4142);
   7334                     expression();
   7335 
   7336                     state._fsp--;
   7337                     if (state.failed) return ;
   7338                     dbg.location(847,20);
   7339                     // src/com/google/doclava/parser/Java.g:847:20: ( ':' expression )?
   7340                     int alt92=2;
   7341                     try { dbg.enterSubRule(92);
   7342                     try { dbg.enterDecision(92, decisionCanBacktrack[92]);
   7343 
   7344                     int LA92_0 = input.LA(1);
   7345 
   7346                     if ( (LA92_0==COLON) ) {
   7347                         alt92=1;
   7348                     }
   7349                     } finally {dbg.exitDecision(92);}
   7350 
   7351                     switch (alt92) {
   7352                         case 1 :
   7353                             dbg.enterAlt(1);
   7354 
   7355                             // src/com/google/doclava/parser/Java.g:847:21: ':' expression
   7356                             {
   7357                             dbg.location(847,21);
   7358                             match(input,COLON,FOLLOW_COLON_in_statement4145); if (state.failed) return ;
   7359                             dbg.location(847,25);
   7360                             pushFollow(FOLLOW_expression_in_statement4147);
   7361                             expression();
   7362 
   7363                             state._fsp--;
   7364                             if (state.failed) return ;
   7365 
   7366                             }
   7367                             break;
   7368 
   7369                     }
   7370                     } finally {dbg.exitSubRule(92);}
   7371 
   7372                     dbg.location(847,38);
   7373                     match(input,SEMI,FOLLOW_SEMI_in_statement4151); if (state.failed) return ;
   7374 
   7375                     }
   7376                     break;
   7377                 case 3 :
   7378                     dbg.enterAlt(3);
   7379 
   7380                     // src/com/google/doclava/parser/Java.g:848:9: 'assert' expression ( ':' expression )? ';'
   7381                     {
   7382                     dbg.location(848,9);
   7383                     match(input,ASSERT,FOLLOW_ASSERT_in_statement4161); if (state.failed) return ;
   7384                     dbg.location(848,19);
   7385                     pushFollow(FOLLOW_expression_in_statement4164);
   7386                     expression();
   7387 
   7388                     state._fsp--;
   7389                     if (state.failed) return ;
   7390                     dbg.location(848,30);
   7391                     // src/com/google/doclava/parser/Java.g:848:30: ( ':' expression )?
   7392                     int alt93=2;
   7393                     try { dbg.enterSubRule(93);
   7394                     try { dbg.enterDecision(93, decisionCanBacktrack[93]);
   7395 
   7396                     int LA93_0 = input.LA(1);
   7397 
   7398                     if ( (LA93_0==COLON) ) {
   7399                         alt93=1;
   7400                     }
   7401                     } finally {dbg.exitDecision(93);}
   7402 
   7403                     switch (alt93) {
   7404                         case 1 :
   7405                             dbg.enterAlt(1);
   7406 
   7407                             // src/com/google/doclava/parser/Java.g:848:31: ':' expression
   7408                             {
   7409                             dbg.location(848,31);
   7410                             match(input,COLON,FOLLOW_COLON_in_statement4167); if (state.failed) return ;
   7411                             dbg.location(848,35);
   7412                             pushFollow(FOLLOW_expression_in_statement4169);
   7413                             expression();
   7414 
   7415                             state._fsp--;
   7416                             if (state.failed) return ;
   7417 
   7418                             }
   7419                             break;
   7420 
   7421                     }
   7422                     } finally {dbg.exitSubRule(93);}
   7423 
   7424                     dbg.location(848,48);
   7425                     match(input,SEMI,FOLLOW_SEMI_in_statement4173); if (state.failed) return ;
   7426 
   7427                     }
   7428                     break;
   7429                 case 4 :
   7430                     dbg.enterAlt(4);
   7431 
   7432                     // src/com/google/doclava/parser/Java.g:849:9: 'if' parExpression statement ( 'else' statement )?
   7433                     {
   7434                     dbg.location(849,9);
   7435                     match(input,IF,FOLLOW_IF_in_statement4183); if (state.failed) return ;
   7436                     dbg.location(849,14);
   7437                     pushFollow(FOLLOW_parExpression_in_statement4185);
   7438                     parExpression();
   7439 
   7440                     state._fsp--;
   7441                     if (state.failed) return ;
   7442                     dbg.location(849,28);
   7443                     pushFollow(FOLLOW_statement_in_statement4187);
   7444                     statement();
   7445 
   7446                     state._fsp--;
   7447                     if (state.failed) return ;
   7448                     dbg.location(849,38);
   7449                     // src/com/google/doclava/parser/Java.g:849:38: ( 'else' statement )?
   7450                     int alt94=2;
   7451                     try { dbg.enterSubRule(94);
   7452                     try { dbg.enterDecision(94, decisionCanBacktrack[94]);
   7453 
   7454                     int LA94_0 = input.LA(1);
   7455 
   7456                     if ( (LA94_0==ELSE) ) {
   7457                         int LA94_1 = input.LA(2);
   7458 
   7459                         if ( (synpred133_Java()) ) {
   7460                             alt94=1;
   7461                         }
   7462                     }
   7463                     } finally {dbg.exitDecision(94);}
   7464 
   7465                     switch (alt94) {
   7466                         case 1 :
   7467                             dbg.enterAlt(1);
   7468 
   7469                             // src/com/google/doclava/parser/Java.g:849:39: 'else' statement
   7470                             {
   7471                             dbg.location(849,39);
   7472                             match(input,ELSE,FOLLOW_ELSE_in_statement4190); if (state.failed) return ;
   7473                             dbg.location(849,46);
   7474                             pushFollow(FOLLOW_statement_in_statement4192);
   7475                             statement();
   7476 
   7477                             state._fsp--;
   7478                             if (state.failed) return ;
   7479 
   7480                             }
   7481                             break;
   7482 
   7483                     }
   7484                     } finally {dbg.exitSubRule(94);}
   7485 
   7486 
   7487                     }
   7488                     break;
   7489                 case 5 :
   7490                     dbg.enterAlt(5);
   7491 
   7492                     // src/com/google/doclava/parser/Java.g:850:9: forstatement
   7493                     {
   7494                     dbg.location(850,9);
   7495                     pushFollow(FOLLOW_forstatement_in_statement4204);
   7496                     forstatement();
   7497 
   7498                     state._fsp--;
   7499                     if (state.failed) return ;
   7500 
   7501                     }
   7502                     break;
   7503                 case 6 :
   7504                     dbg.enterAlt(6);
   7505 
   7506                     // src/com/google/doclava/parser/Java.g:851:9: 'while' parExpression statement
   7507                     {
   7508                     dbg.location(851,9);
   7509                     match(input,WHILE,FOLLOW_WHILE_in_statement4214); if (state.failed) return ;
   7510                     dbg.location(851,17);
   7511                     pushFollow(FOLLOW_parExpression_in_statement4216);
   7512                     parExpression();
   7513 
   7514                     state._fsp--;
   7515                     if (state.failed) return ;
   7516                     dbg.location(851,31);
   7517                     pushFollow(FOLLOW_statement_in_statement4218);
   7518                     statement();
   7519 
   7520                     state._fsp--;
   7521                     if (state.failed) return ;
   7522 
   7523                     }
   7524                     break;
   7525                 case 7 :
   7526                     dbg.enterAlt(7);
   7527 
   7528                     // src/com/google/doclava/parser/Java.g:852:9: 'do' statement 'while' parExpression ';'
   7529                     {
   7530                     dbg.location(852,9);
   7531                     match(input,DO,FOLLOW_DO_in_statement4228); if (state.failed) return ;
   7532                     dbg.location(852,14);
   7533                     pushFollow(FOLLOW_statement_in_statement4230);
   7534                     statement();
   7535 
   7536                     state._fsp--;
   7537                     if (state.failed) return ;
   7538                     dbg.location(852,24);
   7539                     match(input,WHILE,FOLLOW_WHILE_in_statement4232); if (state.failed) return ;
   7540                     dbg.location(852,32);
   7541                     pushFollow(FOLLOW_parExpression_in_statement4234);
   7542                     parExpression();
   7543 
   7544                     state._fsp--;
   7545                     if (state.failed) return ;
   7546                     dbg.location(852,46);
   7547                     match(input,SEMI,FOLLOW_SEMI_in_statement4236); if (state.failed) return ;
   7548 
   7549                     }
   7550                     break;
   7551                 case 8 :
   7552                     dbg.enterAlt(8);
   7553 
   7554                     // src/com/google/doclava/parser/Java.g:853:9: trystatement
   7555                     {
   7556                     dbg.location(853,9);
   7557                     pushFollow(FOLLOW_trystatement_in_statement4246);
   7558                     trystatement();
   7559 
   7560                     state._fsp--;
   7561                     if (state.failed) return ;
   7562 
   7563                     }
   7564                     break;
   7565                 case 9 :
   7566                     dbg.enterAlt(9);
   7567 
   7568                     // src/com/google/doclava/parser/Java.g:854:9: 'switch' parExpression '{' switchBlockStatementGroups '}'
   7569                     {
   7570                     dbg.location(854,9);
   7571                     match(input,SWITCH,FOLLOW_SWITCH_in_statement4256); if (state.failed) return ;
   7572                     dbg.location(854,18);
   7573                     pushFollow(FOLLOW_parExpression_in_statement4258);
   7574                     parExpression();
   7575 
   7576                     state._fsp--;
   7577                     if (state.failed) return ;
   7578                     dbg.location(854,32);
   7579                     match(input,LBRACE,FOLLOW_LBRACE_in_statement4260); if (state.failed) return ;
   7580                     dbg.location(854,36);
   7581                     pushFollow(FOLLOW_switchBlockStatementGroups_in_statement4262);
   7582                     switchBlockStatementGroups();
   7583 
   7584                     state._fsp--;
   7585                     if (state.failed) return ;
   7586                     dbg.location(854,63);
   7587                     match(input,RBRACE,FOLLOW_RBRACE_in_statement4264); if (state.failed) return ;
   7588 
   7589                     }
   7590                     break;
   7591                 case 10 :
   7592                     dbg.enterAlt(10);
   7593 
   7594                     // src/com/google/doclava/parser/Java.g:855:9: 'synchronized' parExpression block
   7595                     {
   7596                     dbg.location(855,9);
   7597                     match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_statement4274); if (state.failed) return ;
   7598                     dbg.location(855,24);
   7599                     pushFollow(FOLLOW_parExpression_in_statement4276);
   7600                     parExpression();
   7601 
   7602                     state._fsp--;
   7603                     if (state.failed) return ;
   7604                     dbg.location(855,38);
   7605                     pushFollow(FOLLOW_block_in_statement4278);
   7606                     block();
   7607 
   7608                     state._fsp--;
   7609                     if (state.failed) return ;
   7610 
   7611                     }
   7612                     break;
   7613                 case 11 :
   7614                     dbg.enterAlt(11);
   7615 
   7616                     // src/com/google/doclava/parser/Java.g:856:9: 'return' ( expression )? ';'
   7617                     {
   7618                     dbg.location(856,9);
   7619                     match(input,RETURN,FOLLOW_RETURN_in_statement4288); if (state.failed) return ;
   7620                     dbg.location(856,18);
   7621                     // src/com/google/doclava/parser/Java.g:856:18: ( expression )?
   7622                     int alt95=2;
   7623                     try { dbg.enterSubRule(95);
   7624                     try { dbg.enterDecision(95, decisionCanBacktrack[95]);
   7625 
   7626                     int LA95_0 = input.LA(1);
   7627 
   7628                     if ( ((LA95_0>=IDENTIFIER && LA95_0<=NULL)||LA95_0==BOOLEAN||LA95_0==BYTE||LA95_0==CHAR||LA95_0==DOUBLE||LA95_0==FLOAT||LA95_0==INT||LA95_0==LONG||LA95_0==NEW||LA95_0==SHORT||LA95_0==SUPER||LA95_0==THIS||LA95_0==VOID||LA95_0==LPAREN||(LA95_0>=BANG && LA95_0<=TILDE)||(LA95_0>=PLUSPLUS && LA95_0<=SUB)) ) {
   7629                         alt95=1;
   7630                     }
   7631                     } finally {dbg.exitDecision(95);}
   7632 
   7633                     switch (alt95) {
   7634                         case 1 :
   7635                             dbg.enterAlt(1);
   7636 
   7637                             // src/com/google/doclava/parser/Java.g:856:19: expression
   7638                             {
   7639                             dbg.location(856,19);
   7640                             pushFollow(FOLLOW_expression_in_statement4291);
   7641                             expression();
   7642 
   7643                             state._fsp--;
   7644                             if (state.failed) return ;
   7645 
   7646                             }
   7647                             break;
   7648 
   7649                     }
   7650                     } finally {dbg.exitSubRule(95);}
   7651 
   7652                     dbg.location(856,33);
   7653                     match(input,SEMI,FOLLOW_SEMI_in_statement4296); if (state.failed) return ;
   7654 
   7655                     }
   7656                     break;
   7657                 case 12 :
   7658                     dbg.enterAlt(12);
   7659 
   7660                     // src/com/google/doclava/parser/Java.g:857:9: 'throw' expression ';'
   7661                     {
   7662                     dbg.location(857,9);
   7663                     match(input,THROW,FOLLOW_THROW_in_statement4306); if (state.failed) return ;
   7664                     dbg.location(857,17);
   7665                     pushFollow(FOLLOW_expression_in_statement4308);
   7666                     expression();
   7667 
   7668                     state._fsp--;
   7669                     if (state.failed) return ;
   7670                     dbg.location(857,28);
   7671                     match(input,SEMI,FOLLOW_SEMI_in_statement4310); if (state.failed) return ;
   7672 
   7673                     }
   7674                     break;
   7675                 case 13 :
   7676                     dbg.enterAlt(13);
   7677 
   7678                     // src/com/google/doclava/parser/Java.g:858:9: 'break' ( IDENTIFIER )? ';'
   7679                     {
   7680                     dbg.location(858,9);
   7681                     match(input,BREAK,FOLLOW_BREAK_in_statement4320); if (state.failed) return ;
   7682                     dbg.location(859,13);
   7683                     // src/com/google/doclava/parser/Java.g:859:13: ( IDENTIFIER )?
   7684                     int alt96=2;
   7685                     try { dbg.enterSubRule(96);
   7686                     try { dbg.enterDecision(96, decisionCanBacktrack[96]);
   7687 
   7688                     int LA96_0 = input.LA(1);
   7689 
   7690                     if ( (LA96_0==IDENTIFIER) ) {
   7691                         alt96=1;
   7692                     }
   7693                     } finally {dbg.exitDecision(96);}
   7694 
   7695                     switch (alt96) {
   7696                         case 1 :
   7697                             dbg.enterAlt(1);
   7698 
   7699                             // src/com/google/doclava/parser/Java.g:859:14: IDENTIFIER
   7700                             {
   7701                             dbg.location(859,14);
   7702                             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4335); if (state.failed) return ;
   7703 
   7704                             }
   7705                             break;
   7706 
   7707                     }
   7708                     } finally {dbg.exitSubRule(96);}
   7709 
   7710                     dbg.location(860,16);
   7711                     match(input,SEMI,FOLLOW_SEMI_in_statement4352); if (state.failed) return ;
   7712 
   7713                     }
   7714                     break;
   7715                 case 14 :
   7716                     dbg.enterAlt(14);
   7717 
   7718                     // src/com/google/doclava/parser/Java.g:861:9: 'continue' ( IDENTIFIER )? ';'
   7719                     {
   7720                     dbg.location(861,9);
   7721                     match(input,CONTINUE,FOLLOW_CONTINUE_in_statement4362); if (state.failed) return ;
   7722                     dbg.location(862,13);
   7723                     // src/com/google/doclava/parser/Java.g:862:13: ( IDENTIFIER )?
   7724                     int alt97=2;
   7725                     try { dbg.enterSubRule(97);
   7726                     try { dbg.enterDecision(97, decisionCanBacktrack[97]);
   7727 
   7728                     int LA97_0 = input.LA(1);
   7729 
   7730                     if ( (LA97_0==IDENTIFIER) ) {
   7731                         alt97=1;
   7732                     }
   7733                     } finally {dbg.exitDecision(97);}
   7734 
   7735                     switch (alt97) {
   7736                         case 1 :
   7737                             dbg.enterAlt(1);
   7738 
   7739                             // src/com/google/doclava/parser/Java.g:862:14: IDENTIFIER
   7740                             {
   7741                             dbg.location(862,14);
   7742                             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4377); if (state.failed) return ;
   7743 
   7744                             }
   7745                             break;
   7746 
   7747                     }
   7748                     } finally {dbg.exitSubRule(97);}
   7749 
   7750                     dbg.location(863,16);
   7751                     match(input,SEMI,FOLLOW_SEMI_in_statement4394); if (state.failed) return ;
   7752 
   7753                     }
   7754                     break;
   7755                 case 15 :
   7756                     dbg.enterAlt(15);
   7757 
   7758                     // src/com/google/doclava/parser/Java.g:864:9: expression ';'
   7759                     {
   7760                     dbg.location(864,9);
   7761                     pushFollow(FOLLOW_expression_in_statement4404);
   7762                     expression();
   7763 
   7764                     state._fsp--;
   7765                     if (state.failed) return ;
   7766                     dbg.location(864,21);
   7767                     match(input,SEMI,FOLLOW_SEMI_in_statement4407); if (state.failed) return ;
   7768 
   7769                     }
   7770                     break;
   7771                 case 16 :
   7772                     dbg.enterAlt(16);
   7773 
   7774                     // src/com/google/doclava/parser/Java.g:865:9: IDENTIFIER ':' statement
   7775                     {
   7776                     dbg.location(865,9);
   7777                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4417); if (state.failed) return ;
   7778                     dbg.location(865,20);
   7779                     match(input,COLON,FOLLOW_COLON_in_statement4419); if (state.failed) return ;
   7780                     dbg.location(865,24);
   7781                     pushFollow(FOLLOW_statement_in_statement4421);
   7782                     statement();
   7783 
   7784                     state._fsp--;
   7785                     if (state.failed) return ;
   7786 
   7787                     }
   7788                     break;
   7789                 case 17 :
   7790                     dbg.enterAlt(17);
   7791 
   7792                     // src/com/google/doclava/parser/Java.g:866:9: ';'
   7793                     {
   7794                     dbg.location(866,9);
   7795                     match(input,SEMI,FOLLOW_SEMI_in_statement4431); if (state.failed) return ;
   7796 
   7797                     }
   7798                     break;
   7799 
   7800             }
   7801         }
   7802         catch (RecognitionException re) {
   7803             reportError(re);
   7804             recover(input,re);
   7805         }
   7806         finally {
   7807             if ( state.backtracking>0 ) { memoize(input, 58, statement_StartIndex); }
   7808         }
   7809         dbg.location(868, 5);
   7810 
   7811         }
   7812         finally {
   7813             dbg.exitRule(getGrammarFileName(), "statement");
   7814             decRuleLevel();
   7815             if ( getRuleLevel()==0 ) {dbg.terminate();}
   7816         }
   7817 
   7818         return ;
   7819     }
   7820     // $ANTLR end "statement"
   7821 
   7822 
   7823     // $ANTLR start "switchBlockStatementGroups"
   7824     // src/com/google/doclava/parser/Java.g:870:1: switchBlockStatementGroups : ( switchBlockStatementGroup )* ;
   7825     public final void switchBlockStatementGroups() throws RecognitionException {
   7826         int switchBlockStatementGroups_StartIndex = input.index();
   7827         try { dbg.enterRule(getGrammarFileName(), "switchBlockStatementGroups");
   7828         if ( getRuleLevel()==0 ) {dbg.commence();}
   7829         incRuleLevel();
   7830         dbg.location(870, 1);
   7831 
   7832         try {
   7833             if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return ; }
   7834             // src/com/google/doclava/parser/Java.g:871:5: ( ( switchBlockStatementGroup )* )
   7835             dbg.enterAlt(1);
   7836 
   7837             // src/com/google/doclava/parser/Java.g:871:9: ( switchBlockStatementGroup )*
   7838             {
   7839             dbg.location(871,9);
   7840             // src/com/google/doclava/parser/Java.g:871:9: ( switchBlockStatementGroup )*
   7841             try { dbg.enterSubRule(99);
   7842 
   7843             loop99:
   7844             do {
   7845                 int alt99=2;
   7846                 try { dbg.enterDecision(99, decisionCanBacktrack[99]);
   7847 
   7848                 int LA99_0 = input.LA(1);
   7849 
   7850                 if ( (LA99_0==CASE||LA99_0==DEFAULT) ) {
   7851                     alt99=1;
   7852                 }
   7853 
   7854 
   7855                 } finally {dbg.exitDecision(99);}
   7856 
   7857                 switch (alt99) {
   7858 		case 1 :
   7859 		    dbg.enterAlt(1);
   7860 
   7861 		    // src/com/google/doclava/parser/Java.g:871:10: switchBlockStatementGroup
   7862 		    {
   7863 		    dbg.location(871,10);
   7864 		    pushFollow(FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups4452);
   7865 		    switchBlockStatementGroup();
   7866 
   7867 		    state._fsp--;
   7868 		    if (state.failed) return ;
   7869 
   7870 		    }
   7871 		    break;
   7872 
   7873 		default :
   7874 		    break loop99;
   7875                 }
   7876             } while (true);
   7877             } finally {dbg.exitSubRule(99);}
   7878 
   7879 
   7880             }
   7881 
   7882         }
   7883         catch (RecognitionException re) {
   7884             reportError(re);
   7885             recover(input,re);
   7886         }
   7887         finally {
   7888             if ( state.backtracking>0 ) { memoize(input, 59, switchBlockStatementGroups_StartIndex); }
   7889         }
   7890         dbg.location(872, 5);
   7891 
   7892         }
   7893         finally {
   7894             dbg.exitRule(getGrammarFileName(), "switchBlockStatementGroups");
   7895             decRuleLevel();
   7896             if ( getRuleLevel()==0 ) {dbg.terminate();}
   7897         }
   7898 
   7899         return ;
   7900     }
   7901     // $ANTLR end "switchBlockStatementGroups"
   7902 
   7903 
   7904     // $ANTLR start "switchBlockStatementGroup"
   7905     // src/com/google/doclava/parser/Java.g:874:1: switchBlockStatementGroup : switchLabel ( blockStatement )* ;
   7906     public final void switchBlockStatementGroup() throws RecognitionException {
   7907         int switchBlockStatementGroup_StartIndex = input.index();
   7908         try { dbg.enterRule(getGrammarFileName(), "switchBlockStatementGroup");
   7909         if ( getRuleLevel()==0 ) {dbg.commence();}
   7910         incRuleLevel();
   7911         dbg.location(874, 1);
   7912 
   7913         try {
   7914             if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return ; }
   7915             // src/com/google/doclava/parser/Java.g:875:5: ( switchLabel ( blockStatement )* )
   7916             dbg.enterAlt(1);
   7917 
   7918             // src/com/google/doclava/parser/Java.g:876:9: switchLabel ( blockStatement )*
   7919             {
   7920             dbg.location(876,9);
   7921             pushFollow(FOLLOW_switchLabel_in_switchBlockStatementGroup4480);
   7922             switchLabel();
   7923 
   7924             state._fsp--;
   7925             if (state.failed) return ;
   7926             dbg.location(877,9);
   7927             // src/com/google/doclava/parser/Java.g:877:9: ( blockStatement )*
   7928             try { dbg.enterSubRule(100);
   7929 
   7930             loop100:
   7931             do {
   7932                 int alt100=2;
   7933                 try { dbg.enterDecision(100, decisionCanBacktrack[100]);
   7934 
   7935                 int LA100_0 = input.LA(1);
   7936 
   7937                 if ( ((LA100_0>=IDENTIFIER && LA100_0<=NULL)||(LA100_0>=ABSTRACT && LA100_0<=BYTE)||(LA100_0>=CHAR && LA100_0<=CLASS)||LA100_0==CONTINUE||(LA100_0>=DO && LA100_0<=DOUBLE)||LA100_0==ENUM||LA100_0==FINAL||(LA100_0>=FLOAT && LA100_0<=FOR)||LA100_0==IF||(LA100_0>=INT && LA100_0<=NEW)||(LA100_0>=PRIVATE && LA100_0<=THROW)||(LA100_0>=TRANSIENT && LA100_0<=LPAREN)||LA100_0==LBRACE||LA100_0==SEMI||(LA100_0>=BANG && LA100_0<=TILDE)||(LA100_0>=PLUSPLUS && LA100_0<=SUB)||LA100_0==MONKEYS_AT||LA100_0==LT) ) {
   7938                     alt100=1;
   7939                 }
   7940 
   7941 
   7942                 } finally {dbg.exitDecision(100);}
   7943 
   7944                 switch (alt100) {
   7945 		case 1 :
   7946 		    dbg.enterAlt(1);
   7947 
   7948 		    // src/com/google/doclava/parser/Java.g:877:10: blockStatement
   7949 		    {
   7950 		    dbg.location(877,10);
   7951 		    pushFollow(FOLLOW_blockStatement_in_switchBlockStatementGroup4491);
   7952 		    blockStatement();
   7953 
   7954 		    state._fsp--;
   7955 		    if (state.failed) return ;
   7956 
   7957 		    }
   7958 		    break;
   7959 
   7960 		default :
   7961 		    break loop100;
   7962                 }
   7963             } while (true);
   7964             } finally {dbg.exitSubRule(100);}
   7965 
   7966 
   7967             }
   7968 
   7969         }
   7970         catch (RecognitionException re) {
   7971             reportError(re);
   7972             recover(input,re);
   7973         }
   7974         finally {
   7975             if ( state.backtracking>0 ) { memoize(input, 60, switchBlockStatementGroup_StartIndex); }
   7976         }
   7977         dbg.location(879, 5);
   7978 
   7979         }
   7980         finally {
   7981             dbg.exitRule(getGrammarFileName(), "switchBlockStatementGroup");
   7982             decRuleLevel();
   7983             if ( getRuleLevel()==0 ) {dbg.terminate();}
   7984         }
   7985 
   7986         return ;
   7987     }
   7988     // $ANTLR end "switchBlockStatementGroup"
   7989 
   7990 
   7991     // $ANTLR start "switchLabel"
   7992     // src/com/google/doclava/parser/Java.g:881:1: switchLabel : ( 'case' expression ':' | 'default' ':' );
   7993     public final void switchLabel() throws RecognitionException {
   7994         int switchLabel_StartIndex = input.index();
   7995         try { dbg.enterRule(getGrammarFileName(), "switchLabel");
   7996         if ( getRuleLevel()==0 ) {dbg.commence();}
   7997         incRuleLevel();
   7998         dbg.location(881, 1);
   7999 
   8000         try {
   8001             if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return ; }
   8002             // src/com/google/doclava/parser/Java.g:882:5: ( 'case' expression ':' | 'default' ':' )
   8003             int alt101=2;
   8004             try { dbg.enterDecision(101, decisionCanBacktrack[101]);
   8005 
   8006             int LA101_0 = input.LA(1);
   8007 
   8008             if ( (LA101_0==CASE) ) {
   8009                 alt101=1;
   8010             }
   8011             else if ( (LA101_0==DEFAULT) ) {
   8012                 alt101=2;
   8013             }
   8014             else {
   8015                 if (state.backtracking>0) {state.failed=true; return ;}
   8016                 NoViableAltException nvae =
   8017                     new NoViableAltException("", 101, 0, input);
   8018 
   8019                 dbg.recognitionException(nvae);
   8020                 throw nvae;
   8021             }
   8022             } finally {dbg.exitDecision(101);}
   8023 
   8024             switch (alt101) {
   8025                 case 1 :
   8026                     dbg.enterAlt(1);
   8027 
   8028                     // src/com/google/doclava/parser/Java.g:882:9: 'case' expression ':'
   8029                     {
   8030                     dbg.location(882,9);
   8031                     match(input,CASE,FOLLOW_CASE_in_switchLabel4521); if (state.failed) return ;
   8032                     dbg.location(882,16);
   8033                     pushFollow(FOLLOW_expression_in_switchLabel4523);
   8034                     expression();
   8035 
   8036                     state._fsp--;
   8037                     if (state.failed) return ;
   8038                     dbg.location(882,27);
   8039                     match(input,COLON,FOLLOW_COLON_in_switchLabel4525); if (state.failed) return ;
   8040 
   8041                     }
   8042                     break;
   8043                 case 2 :
   8044                     dbg.enterAlt(2);
   8045 
   8046                     // src/com/google/doclava/parser/Java.g:883:9: 'default' ':'
   8047                     {
   8048                     dbg.location(883,9);
   8049                     match(input,DEFAULT,FOLLOW_DEFAULT_in_switchLabel4535); if (state.failed) return ;
   8050                     dbg.location(883,19);
   8051                     match(input,COLON,FOLLOW_COLON_in_switchLabel4537); if (state.failed) return ;
   8052 
   8053                     }
   8054                     break;
   8055 
   8056             }
   8057         }
   8058         catch (RecognitionException re) {
   8059             reportError(re);
   8060             recover(input,re);
   8061         }
   8062         finally {
   8063             if ( state.backtracking>0 ) { memoize(input, 61, switchLabel_StartIndex); }
   8064         }
   8065         dbg.location(884, 5);
   8066 
   8067         }
   8068         finally {
   8069             dbg.exitRule(getGrammarFileName(), "switchLabel");
   8070             decRuleLevel();
   8071             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8072         }
   8073 
   8074         return ;
   8075     }
   8076     // $ANTLR end "switchLabel"
   8077 
   8078 
   8079     // $ANTLR start "trystatement"
   8080     // src/com/google/doclava/parser/Java.g:887:1: trystatement : 'try' block ( catches 'finally' block | catches | 'finally' block ) ;
   8081     public final void trystatement() throws RecognitionException {
   8082         int trystatement_StartIndex = input.index();
   8083         try { dbg.enterRule(getGrammarFileName(), "trystatement");
   8084         if ( getRuleLevel()==0 ) {dbg.commence();}
   8085         incRuleLevel();
   8086         dbg.location(887, 1);
   8087 
   8088         try {
   8089             if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return ; }
   8090             // src/com/google/doclava/parser/Java.g:888:5: ( 'try' block ( catches 'finally' block | catches | 'finally' block ) )
   8091             dbg.enterAlt(1);
   8092 
   8093             // src/com/google/doclava/parser/Java.g:888:9: 'try' block ( catches 'finally' block | catches | 'finally' block )
   8094             {
   8095             dbg.location(888,9);
   8096             match(input,TRY,FOLLOW_TRY_in_trystatement4557); if (state.failed) return ;
   8097             dbg.location(888,15);
   8098             pushFollow(FOLLOW_block_in_trystatement4559);
   8099             block();
   8100 
   8101             state._fsp--;
   8102             if (state.failed) return ;
   8103             dbg.location(889,9);
   8104             // src/com/google/doclava/parser/Java.g:889:9: ( catches 'finally' block | catches | 'finally' block )
   8105             int alt102=3;
   8106             try { dbg.enterSubRule(102);
   8107             try { dbg.enterDecision(102, decisionCanBacktrack[102]);
   8108 
   8109             int LA102_0 = input.LA(1);
   8110 
   8111             if ( (LA102_0==CATCH) ) {
   8112                 int LA102_1 = input.LA(2);
   8113 
   8114                 if ( (synpred153_Java()) ) {
   8115                     alt102=1;
   8116                 }
   8117                 else if ( (synpred154_Java()) ) {
   8118                     alt102=2;
   8119                 }
   8120                 else {
   8121                     if (state.backtracking>0) {state.failed=true; return ;}
   8122                     NoViableAltException nvae =
   8123                         new NoViableAltException("", 102, 1, input);
   8124 
   8125                     dbg.recognitionException(nvae);
   8126                     throw nvae;
   8127                 }
   8128             }
   8129             else if ( (LA102_0==FINALLY) ) {
   8130                 alt102=3;
   8131             }
   8132             else {
   8133                 if (state.backtracking>0) {state.failed=true; return ;}
   8134                 NoViableAltException nvae =
   8135                     new NoViableAltException("", 102, 0, input);
   8136 
   8137                 dbg.recognitionException(nvae);
   8138                 throw nvae;
   8139             }
   8140             } finally {dbg.exitDecision(102);}
   8141 
   8142             switch (alt102) {
   8143                 case 1 :
   8144                     dbg.enterAlt(1);
   8145 
   8146                     // src/com/google/doclava/parser/Java.g:889:13: catches 'finally' block
   8147                     {
   8148                     dbg.location(889,13);
   8149                     pushFollow(FOLLOW_catches_in_trystatement4573);
   8150                     catches();
   8151 
   8152                     state._fsp--;
   8153                     if (state.failed) return ;
   8154                     dbg.location(889,21);
   8155                     match(input,FINALLY,FOLLOW_FINALLY_in_trystatement4575); if (state.failed) return ;
   8156                     dbg.location(889,31);
   8157                     pushFollow(FOLLOW_block_in_trystatement4577);
   8158                     block();
   8159 
   8160                     state._fsp--;
   8161                     if (state.failed) return ;
   8162 
   8163                     }
   8164                     break;
   8165                 case 2 :
   8166                     dbg.enterAlt(2);
   8167 
   8168                     // src/com/google/doclava/parser/Java.g:890:13: catches
   8169                     {
   8170                     dbg.location(890,13);
   8171                     pushFollow(FOLLOW_catches_in_trystatement4591);
   8172                     catches();
   8173 
   8174                     state._fsp--;
   8175                     if (state.failed) return ;
   8176 
   8177                     }
   8178                     break;
   8179                 case 3 :
   8180                     dbg.enterAlt(3);
   8181 
   8182                     // src/com/google/doclava/parser/Java.g:891:13: 'finally' block
   8183                     {
   8184                     dbg.location(891,13);
   8185                     match(input,FINALLY,FOLLOW_FINALLY_in_trystatement4605); if (state.failed) return ;
   8186                     dbg.location(891,23);
   8187                     pushFollow(FOLLOW_block_in_trystatement4607);
   8188                     block();
   8189 
   8190                     state._fsp--;
   8191                     if (state.failed) return ;
   8192 
   8193                     }
   8194                     break;
   8195 
   8196             }
   8197             } finally {dbg.exitSubRule(102);}
   8198 
   8199 
   8200             }
   8201 
   8202         }
   8203         catch (RecognitionException re) {
   8204             reportError(re);
   8205             recover(input,re);
   8206         }
   8207         finally {
   8208             if ( state.backtracking>0 ) { memoize(input, 62, trystatement_StartIndex); }
   8209         }
   8210         dbg.location(893, 6);
   8211 
   8212         }
   8213         finally {
   8214             dbg.exitRule(getGrammarFileName(), "trystatement");
   8215             decRuleLevel();
   8216             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8217         }
   8218 
   8219         return ;
   8220     }
   8221     // $ANTLR end "trystatement"
   8222 
   8223 
   8224     // $ANTLR start "catches"
   8225     // src/com/google/doclava/parser/Java.g:895:1: catches : catchClause ( catchClause )* ;
   8226     public final void catches() throws RecognitionException {
   8227         int catches_StartIndex = input.index();
   8228         try { dbg.enterRule(getGrammarFileName(), "catches");
   8229         if ( getRuleLevel()==0 ) {dbg.commence();}
   8230         incRuleLevel();
   8231         dbg.location(895, 1);
   8232 
   8233         try {
   8234             if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return ; }
   8235             // src/com/google/doclava/parser/Java.g:896:5: ( catchClause ( catchClause )* )
   8236             dbg.enterAlt(1);
   8237 
   8238             // src/com/google/doclava/parser/Java.g:896:9: catchClause ( catchClause )*
   8239             {
   8240             dbg.location(896,9);
   8241             pushFollow(FOLLOW_catchClause_in_catches4637);
   8242             catchClause();
   8243 
   8244             state._fsp--;
   8245             if (state.failed) return ;
   8246             dbg.location(897,9);
   8247             // src/com/google/doclava/parser/Java.g:897:9: ( catchClause )*
   8248             try { dbg.enterSubRule(103);
   8249 
   8250             loop103:
   8251             do {
   8252                 int alt103=2;
   8253                 try { dbg.enterDecision(103, decisionCanBacktrack[103]);
   8254 
   8255                 int LA103_0 = input.LA(1);
   8256 
   8257                 if ( (LA103_0==CATCH) ) {
   8258                     alt103=1;
   8259                 }
   8260 
   8261 
   8262                 } finally {dbg.exitDecision(103);}
   8263 
   8264                 switch (alt103) {
   8265 		case 1 :
   8266 		    dbg.enterAlt(1);
   8267 
   8268 		    // src/com/google/doclava/parser/Java.g:897:10: catchClause
   8269 		    {
   8270 		    dbg.location(897,10);
   8271 		    pushFollow(FOLLOW_catchClause_in_catches4648);
   8272 		    catchClause();
   8273 
   8274 		    state._fsp--;
   8275 		    if (state.failed) return ;
   8276 
   8277 		    }
   8278 		    break;
   8279 
   8280 		default :
   8281 		    break loop103;
   8282                 }
   8283             } while (true);
   8284             } finally {dbg.exitSubRule(103);}
   8285 
   8286 
   8287             }
   8288 
   8289         }
   8290         catch (RecognitionException re) {
   8291             reportError(re);
   8292             recover(input,re);
   8293         }
   8294         finally {
   8295             if ( state.backtracking>0 ) { memoize(input, 63, catches_StartIndex); }
   8296         }
   8297         dbg.location(899, 5);
   8298 
   8299         }
   8300         finally {
   8301             dbg.exitRule(getGrammarFileName(), "catches");
   8302             decRuleLevel();
   8303             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8304         }
   8305 
   8306         return ;
   8307     }
   8308     // $ANTLR end "catches"
   8309 
   8310 
   8311     // $ANTLR start "catchClause"
   8312     // src/com/google/doclava/parser/Java.g:901:1: catchClause : 'catch' '(' formalParameter ')' block ;
   8313     public final void catchClause() throws RecognitionException {
   8314         int catchClause_StartIndex = input.index();
   8315         try { dbg.enterRule(getGrammarFileName(), "catchClause");
   8316         if ( getRuleLevel()==0 ) {dbg.commence();}
   8317         incRuleLevel();
   8318         dbg.location(901, 1);
   8319 
   8320         try {
   8321             if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return ; }
   8322             // src/com/google/doclava/parser/Java.g:902:5: ( 'catch' '(' formalParameter ')' block )
   8323             dbg.enterAlt(1);
   8324 
   8325             // src/com/google/doclava/parser/Java.g:902:9: 'catch' '(' formalParameter ')' block
   8326             {
   8327             dbg.location(902,9);
   8328             match(input,CATCH,FOLLOW_CATCH_in_catchClause4678); if (state.failed) return ;
   8329             dbg.location(902,17);
   8330             match(input,LPAREN,FOLLOW_LPAREN_in_catchClause4680); if (state.failed) return ;
   8331             dbg.location(902,21);
   8332             pushFollow(FOLLOW_formalParameter_in_catchClause4682);
   8333             formalParameter();
   8334 
   8335             state._fsp--;
   8336             if (state.failed) return ;
   8337             dbg.location(903,9);
   8338             match(input,RPAREN,FOLLOW_RPAREN_in_catchClause4692); if (state.failed) return ;
   8339             dbg.location(903,13);
   8340             pushFollow(FOLLOW_block_in_catchClause4694);
   8341             block();
   8342 
   8343             state._fsp--;
   8344             if (state.failed) return ;
   8345 
   8346             }
   8347 
   8348         }
   8349         catch (RecognitionException re) {
   8350             reportError(re);
   8351             recover(input,re);
   8352         }
   8353         finally {
   8354             if ( state.backtracking>0 ) { memoize(input, 64, catchClause_StartIndex); }
   8355         }
   8356         dbg.location(904, 5);
   8357 
   8358         }
   8359         finally {
   8360             dbg.exitRule(getGrammarFileName(), "catchClause");
   8361             decRuleLevel();
   8362             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8363         }
   8364 
   8365         return ;
   8366     }
   8367     // $ANTLR end "catchClause"
   8368 
   8369 
   8370     // $ANTLR start "formalParameter"
   8371     // src/com/google/doclava/parser/Java.g:906:1: formalParameter : variableModifiers type IDENTIFIER ( '[' ']' )* ;
   8372     public final void formalParameter() throws RecognitionException {
   8373         int formalParameter_StartIndex = input.index();
   8374         try { dbg.enterRule(getGrammarFileName(), "formalParameter");
   8375         if ( getRuleLevel()==0 ) {dbg.commence();}
   8376         incRuleLevel();
   8377         dbg.location(906, 1);
   8378 
   8379         try {
   8380             if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return ; }
   8381             // src/com/google/doclava/parser/Java.g:907:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* )
   8382             dbg.enterAlt(1);
   8383 
   8384             // src/com/google/doclava/parser/Java.g:907:9: variableModifiers type IDENTIFIER ( '[' ']' )*
   8385             {
   8386             dbg.location(907,9);
   8387             pushFollow(FOLLOW_variableModifiers_in_formalParameter4713);
   8388             variableModifiers();
   8389 
   8390             state._fsp--;
   8391             if (state.failed) return ;
   8392             dbg.location(907,27);
   8393             pushFollow(FOLLOW_type_in_formalParameter4715);
   8394             type();
   8395 
   8396             state._fsp--;
   8397             if (state.failed) return ;
   8398             dbg.location(907,32);
   8399             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_formalParameter4717); if (state.failed) return ;
   8400             dbg.location(908,9);
   8401             // src/com/google/doclava/parser/Java.g:908:9: ( '[' ']' )*
   8402             try { dbg.enterSubRule(104);
   8403 
   8404             loop104:
   8405             do {
   8406                 int alt104=2;
   8407                 try { dbg.enterDecision(104, decisionCanBacktrack[104]);
   8408 
   8409                 int LA104_0 = input.LA(1);
   8410 
   8411                 if ( (LA104_0==LBRACKET) ) {
   8412                     alt104=1;
   8413                 }
   8414 
   8415 
   8416                 } finally {dbg.exitDecision(104);}
   8417 
   8418                 switch (alt104) {
   8419 		case 1 :
   8420 		    dbg.enterAlt(1);
   8421 
   8422 		    // src/com/google/doclava/parser/Java.g:908:10: '[' ']'
   8423 		    {
   8424 		    dbg.location(908,10);
   8425 		    match(input,LBRACKET,FOLLOW_LBRACKET_in_formalParameter4728); if (state.failed) return ;
   8426 		    dbg.location(908,14);
   8427 		    match(input,RBRACKET,FOLLOW_RBRACKET_in_formalParameter4730); if (state.failed) return ;
   8428 
   8429 		    }
   8430 		    break;
   8431 
   8432 		default :
   8433 		    break loop104;
   8434                 }
   8435             } while (true);
   8436             } finally {dbg.exitSubRule(104);}
   8437 
   8438 
   8439             }
   8440 
   8441         }
   8442         catch (RecognitionException re) {
   8443             reportError(re);
   8444             recover(input,re);
   8445         }
   8446         finally {
   8447             if ( state.backtracking>0 ) { memoize(input, 65, formalParameter_StartIndex); }
   8448         }
   8449         dbg.location(910, 5);
   8450 
   8451         }
   8452         finally {
   8453             dbg.exitRule(getGrammarFileName(), "formalParameter");
   8454             decRuleLevel();
   8455             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8456         }
   8457 
   8458         return ;
   8459     }
   8460     // $ANTLR end "formalParameter"
   8461 
   8462 
   8463     // $ANTLR start "forstatement"
   8464     // src/com/google/doclava/parser/Java.g:912:1: forstatement : ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement );
   8465     public final void forstatement() throws RecognitionException {
   8466         int forstatement_StartIndex = input.index();
   8467         try { dbg.enterRule(getGrammarFileName(), "forstatement");
   8468         if ( getRuleLevel()==0 ) {dbg.commence();}
   8469         incRuleLevel();
   8470         dbg.location(912, 1);
   8471 
   8472         try {
   8473             if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return ; }
   8474             // src/com/google/doclava/parser/Java.g:913:5: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement )
   8475             int alt108=2;
   8476             try { dbg.enterDecision(108, decisionCanBacktrack[108]);
   8477 
   8478             int LA108_0 = input.LA(1);
   8479 
   8480             if ( (LA108_0==FOR) ) {
   8481                 int LA108_1 = input.LA(2);
   8482 
   8483                 if ( (synpred157_Java()) ) {
   8484                     alt108=1;
   8485                 }
   8486                 else if ( (true) ) {
   8487                     alt108=2;
   8488                 }
   8489                 else {
   8490                     if (state.backtracking>0) {state.failed=true; return ;}
   8491                     NoViableAltException nvae =
   8492                         new NoViableAltException("", 108, 1, input);
   8493 
   8494                     dbg.recognitionException(nvae);
   8495                     throw nvae;
   8496                 }
   8497             }
   8498             else {
   8499                 if (state.backtracking>0) {state.failed=true; return ;}
   8500                 NoViableAltException nvae =
   8501                     new NoViableAltException("", 108, 0, input);
   8502 
   8503                 dbg.recognitionException(nvae);
   8504                 throw nvae;
   8505             }
   8506             } finally {dbg.exitDecision(108);}
   8507 
   8508             switch (alt108) {
   8509                 case 1 :
   8510                     dbg.enterAlt(1);
   8511 
   8512                     // src/com/google/doclava/parser/Java.g:915:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement
   8513                     {
   8514                     dbg.location(915,9);
   8515                     match(input,FOR,FOLLOW_FOR_in_forstatement4775); if (state.failed) return ;
   8516                     dbg.location(915,15);
   8517                     match(input,LPAREN,FOLLOW_LPAREN_in_forstatement4777); if (state.failed) return ;
   8518                     dbg.location(915,19);
   8519                     pushFollow(FOLLOW_variableModifiers_in_forstatement4779);
   8520                     variableModifiers();
   8521 
   8522                     state._fsp--;
   8523                     if (state.failed) return ;
   8524                     dbg.location(915,37);
   8525                     pushFollow(FOLLOW_type_in_forstatement4781);
   8526                     type();
   8527 
   8528                     state._fsp--;
   8529                     if (state.failed) return ;
   8530                     dbg.location(915,42);
   8531                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_forstatement4783); if (state.failed) return ;
   8532                     dbg.location(915,53);
   8533                     match(input,COLON,FOLLOW_COLON_in_forstatement4785); if (state.failed) return ;
   8534                     dbg.location(916,9);
   8535                     pushFollow(FOLLOW_expression_in_forstatement4795);
   8536                     expression();
   8537 
   8538                     state._fsp--;
   8539                     if (state.failed) return ;
   8540                     dbg.location(916,20);
   8541                     match(input,RPAREN,FOLLOW_RPAREN_in_forstatement4797); if (state.failed) return ;
   8542                     dbg.location(916,24);
   8543                     pushFollow(FOLLOW_statement_in_forstatement4799);
   8544                     statement();
   8545 
   8546                     state._fsp--;
   8547                     if (state.failed) return ;
   8548 
   8549                     }
   8550                     break;
   8551                 case 2 :
   8552                     dbg.enterAlt(2);
   8553 
   8554                     // src/com/google/doclava/parser/Java.g:919:9: 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement
   8555                     {
   8556                     dbg.location(919,9);
   8557                     match(input,FOR,FOLLOW_FOR_in_forstatement4819); if (state.failed) return ;
   8558                     dbg.location(919,15);
   8559                     match(input,LPAREN,FOLLOW_LPAREN_in_forstatement4821); if (state.failed) return ;
   8560                     dbg.location(920,17);
   8561                     // src/com/google/doclava/parser/Java.g:920:17: ( forInit )?
   8562                     int alt105=2;
   8563                     try { dbg.enterSubRule(105);
   8564                     try { dbg.enterDecision(105, decisionCanBacktrack[105]);
   8565 
   8566                     int LA105_0 = input.LA(1);
   8567 
   8568                     if ( ((LA105_0>=IDENTIFIER && LA105_0<=NULL)||LA105_0==BOOLEAN||LA105_0==BYTE||LA105_0==CHAR||LA105_0==DOUBLE||LA105_0==FINAL||LA105_0==FLOAT||LA105_0==INT||LA105_0==LONG||LA105_0==NEW||LA105_0==SHORT||LA105_0==SUPER||LA105_0==THIS||LA105_0==VOID||LA105_0==LPAREN||(LA105_0>=BANG && LA105_0<=TILDE)||(LA105_0>=PLUSPLUS && LA105_0<=SUB)||LA105_0==MONKEYS_AT) ) {
   8569                         alt105=1;
   8570                     }
   8571                     } finally {dbg.exitDecision(105);}
   8572 
   8573                     switch (alt105) {
   8574                         case 1 :
   8575                             dbg.enterAlt(1);
   8576 
   8577                             // src/com/google/doclava/parser/Java.g:920:18: forInit
   8578                             {
   8579                             dbg.location(920,18);
   8580                             pushFollow(FOLLOW_forInit_in_forstatement4840);
   8581                             forInit();
   8582 
   8583                             state._fsp--;
   8584                             if (state.failed) return ;
   8585 
   8586                             }
   8587                             break;
   8588 
   8589                     }
   8590                     } finally {dbg.exitSubRule(105);}
   8591 
   8592                     dbg.location(921,20);
   8593                     match(input,SEMI,FOLLOW_SEMI_in_forstatement4861); if (state.failed) return ;
   8594                     dbg.location(922,17);
   8595                     // src/com/google/doclava/parser/Java.g:922:17: ( expression )?
   8596                     int alt106=2;
   8597                     try { dbg.enterSubRule(106);
   8598                     try { dbg.enterDecision(106, decisionCanBacktrack[106]);
   8599 
   8600                     int LA106_0 = input.LA(1);
   8601 
   8602                     if ( ((LA106_0>=IDENTIFIER && LA106_0<=NULL)||LA106_0==BOOLEAN||LA106_0==BYTE||LA106_0==CHAR||LA106_0==DOUBLE||LA106_0==FLOAT||LA106_0==INT||LA106_0==LONG||LA106_0==NEW||LA106_0==SHORT||LA106_0==SUPER||LA106_0==THIS||LA106_0==VOID||LA106_0==LPAREN||(LA106_0>=BANG && LA106_0<=TILDE)||(LA106_0>=PLUSPLUS && LA106_0<=SUB)) ) {
   8603                         alt106=1;
   8604                     }
   8605                     } finally {dbg.exitDecision(106);}
   8606 
   8607                     switch (alt106) {
   8608                         case 1 :
   8609                             dbg.enterAlt(1);
   8610 
   8611                             // src/com/google/doclava/parser/Java.g:922:18: expression
   8612                             {
   8613                             dbg.location(922,18);
   8614                             pushFollow(FOLLOW_expression_in_forstatement4880);
   8615                             expression();
   8616 
   8617                             state._fsp--;
   8618                             if (state.failed) return ;
   8619 
   8620                             }
   8621                             break;
   8622 
   8623                     }
   8624                     } finally {dbg.exitSubRule(106);}
   8625 
   8626                     dbg.location(923,20);
   8627                     match(input,SEMI,FOLLOW_SEMI_in_forstatement4901); if (state.failed) return ;
   8628                     dbg.location(924,17);
   8629                     // src/com/google/doclava/parser/Java.g:924:17: ( expressionList )?
   8630                     int alt107=2;
   8631                     try { dbg.enterSubRule(107);
   8632                     try { dbg.enterDecision(107, decisionCanBacktrack[107]);
   8633 
   8634                     int LA107_0 = input.LA(1);
   8635 
   8636                     if ( ((LA107_0>=IDENTIFIER && LA107_0<=NULL)||LA107_0==BOOLEAN||LA107_0==BYTE||LA107_0==CHAR||LA107_0==DOUBLE||LA107_0==FLOAT||LA107_0==INT||LA107_0==LONG||LA107_0==NEW||LA107_0==SHORT||LA107_0==SUPER||LA107_0==THIS||LA107_0==VOID||LA107_0==LPAREN||(LA107_0>=BANG && LA107_0<=TILDE)||(LA107_0>=PLUSPLUS && LA107_0<=SUB)) ) {
   8637                         alt107=1;
   8638                     }
   8639                     } finally {dbg.exitDecision(107);}
   8640 
   8641                     switch (alt107) {
   8642                         case 1 :
   8643                             dbg.enterAlt(1);
   8644 
   8645                             // src/com/google/doclava/parser/Java.g:924:18: expressionList
   8646                             {
   8647                             dbg.location(924,18);
   8648                             pushFollow(FOLLOW_expressionList_in_forstatement4920);
   8649                             expressionList();
   8650 
   8651                             state._fsp--;
   8652                             if (state.failed) return ;
   8653 
   8654                             }
   8655                             break;
   8656 
   8657                     }
   8658                     } finally {dbg.exitSubRule(107);}
   8659 
   8660                     dbg.location(925,20);
   8661                     match(input,RPAREN,FOLLOW_RPAREN_in_forstatement4941); if (state.failed) return ;
   8662                     dbg.location(925,24);
   8663                     pushFollow(FOLLOW_statement_in_forstatement4943);
   8664                     statement();
   8665 
   8666                     state._fsp--;
   8667                     if (state.failed) return ;
   8668 
   8669                     }
   8670                     break;
   8671 
   8672             }
   8673         }
   8674         catch (RecognitionException re) {
   8675             reportError(re);
   8676             recover(input,re);
   8677         }
   8678         finally {
   8679             if ( state.backtracking>0 ) { memoize(input, 66, forstatement_StartIndex); }
   8680         }
   8681         dbg.location(926, 5);
   8682 
   8683         }
   8684         finally {
   8685             dbg.exitRule(getGrammarFileName(), "forstatement");
   8686             decRuleLevel();
   8687             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8688         }
   8689 
   8690         return ;
   8691     }
   8692     // $ANTLR end "forstatement"
   8693 
   8694 
   8695     // $ANTLR start "forInit"
   8696     // src/com/google/doclava/parser/Java.g:928:1: forInit : ( localVariableDeclaration | expressionList );
   8697     public final void forInit() throws RecognitionException {
   8698         int forInit_StartIndex = input.index();
   8699         try { dbg.enterRule(getGrammarFileName(), "forInit");
   8700         if ( getRuleLevel()==0 ) {dbg.commence();}
   8701         incRuleLevel();
   8702         dbg.location(928, 1);
   8703 
   8704         try {
   8705             if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return ; }
   8706             // src/com/google/doclava/parser/Java.g:929:5: ( localVariableDeclaration | expressionList )
   8707             int alt109=2;
   8708             try { dbg.enterDecision(109, decisionCanBacktrack[109]);
   8709 
   8710             try {
   8711                 isCyclicDecision = true;
   8712                 alt109 = dfa109.predict(input);
   8713             }
   8714             catch (NoViableAltException nvae) {
   8715                 dbg.recognitionException(nvae);
   8716                 throw nvae;
   8717             }
   8718             } finally {dbg.exitDecision(109);}
   8719 
   8720             switch (alt109) {
   8721                 case 1 :
   8722                     dbg.enterAlt(1);
   8723 
   8724                     // src/com/google/doclava/parser/Java.g:929:9: localVariableDeclaration
   8725                     {
   8726                     dbg.location(929,9);
   8727                     pushFollow(FOLLOW_localVariableDeclaration_in_forInit4962);
   8728                     localVariableDeclaration();
   8729 
   8730                     state._fsp--;
   8731                     if (state.failed) return ;
   8732 
   8733                     }
   8734                     break;
   8735                 case 2 :
   8736                     dbg.enterAlt(2);
   8737 
   8738                     // src/com/google/doclava/parser/Java.g:930:9: expressionList
   8739                     {
   8740                     dbg.location(930,9);
   8741                     pushFollow(FOLLOW_expressionList_in_forInit4972);
   8742                     expressionList();
   8743 
   8744                     state._fsp--;
   8745                     if (state.failed) return ;
   8746 
   8747                     }
   8748                     break;
   8749 
   8750             }
   8751         }
   8752         catch (RecognitionException re) {
   8753             reportError(re);
   8754             recover(input,re);
   8755         }
   8756         finally {
   8757             if ( state.backtracking>0 ) { memoize(input, 67, forInit_StartIndex); }
   8758         }
   8759         dbg.location(931, 5);
   8760 
   8761         }
   8762         finally {
   8763             dbg.exitRule(getGrammarFileName(), "forInit");
   8764             decRuleLevel();
   8765             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8766         }
   8767 
   8768         return ;
   8769     }
   8770     // $ANTLR end "forInit"
   8771 
   8772 
   8773     // $ANTLR start "parExpression"
   8774     // src/com/google/doclava/parser/Java.g:933:1: parExpression : '(' expression ')' ;
   8775     public final void parExpression() throws RecognitionException {
   8776         int parExpression_StartIndex = input.index();
   8777         try { dbg.enterRule(getGrammarFileName(), "parExpression");
   8778         if ( getRuleLevel()==0 ) {dbg.commence();}
   8779         incRuleLevel();
   8780         dbg.location(933, 1);
   8781 
   8782         try {
   8783             if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return ; }
   8784             // src/com/google/doclava/parser/Java.g:934:5: ( '(' expression ')' )
   8785             dbg.enterAlt(1);
   8786 
   8787             // src/com/google/doclava/parser/Java.g:934:9: '(' expression ')'
   8788             {
   8789             dbg.location(934,9);
   8790             match(input,LPAREN,FOLLOW_LPAREN_in_parExpression4991); if (state.failed) return ;
   8791             dbg.location(934,13);
   8792             pushFollow(FOLLOW_expression_in_parExpression4993);
   8793             expression();
   8794 
   8795             state._fsp--;
   8796             if (state.failed) return ;
   8797             dbg.location(934,24);
   8798             match(input,RPAREN,FOLLOW_RPAREN_in_parExpression4995); if (state.failed) return ;
   8799 
   8800             }
   8801 
   8802         }
   8803         catch (RecognitionException re) {
   8804             reportError(re);
   8805             recover(input,re);
   8806         }
   8807         finally {
   8808             if ( state.backtracking>0 ) { memoize(input, 68, parExpression_StartIndex); }
   8809         }
   8810         dbg.location(935, 5);
   8811 
   8812         }
   8813         finally {
   8814             dbg.exitRule(getGrammarFileName(), "parExpression");
   8815             decRuleLevel();
   8816             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8817         }
   8818 
   8819         return ;
   8820     }
   8821     // $ANTLR end "parExpression"
   8822 
   8823 
   8824     // $ANTLR start "expressionList"
   8825     // src/com/google/doclava/parser/Java.g:937:1: expressionList : expression ( ',' expression )* ;
   8826     public final void expressionList() throws RecognitionException {
   8827         int expressionList_StartIndex = input.index();
   8828         try { dbg.enterRule(getGrammarFileName(), "expressionList");
   8829         if ( getRuleLevel()==0 ) {dbg.commence();}
   8830         incRuleLevel();
   8831         dbg.location(937, 1);
   8832 
   8833         try {
   8834             if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return ; }
   8835             // src/com/google/doclava/parser/Java.g:938:5: ( expression ( ',' expression )* )
   8836             dbg.enterAlt(1);
   8837 
   8838             // src/com/google/doclava/parser/Java.g:938:9: expression ( ',' expression )*
   8839             {
   8840             dbg.location(938,9);
   8841             pushFollow(FOLLOW_expression_in_expressionList5014);
   8842             expression();
   8843 
   8844             state._fsp--;
   8845             if (state.failed) return ;
   8846             dbg.location(939,9);
   8847             // src/com/google/doclava/parser/Java.g:939:9: ( ',' expression )*
   8848             try { dbg.enterSubRule(110);
   8849 
   8850             loop110:
   8851             do {
   8852                 int alt110=2;
   8853                 try { dbg.enterDecision(110, decisionCanBacktrack[110]);
   8854 
   8855                 int LA110_0 = input.LA(1);
   8856 
   8857                 if ( (LA110_0==COMMA) ) {
   8858                     alt110=1;
   8859                 }
   8860 
   8861 
   8862                 } finally {dbg.exitDecision(110);}
   8863 
   8864                 switch (alt110) {
   8865 		case 1 :
   8866 		    dbg.enterAlt(1);
   8867 
   8868 		    // src/com/google/doclava/parser/Java.g:939:10: ',' expression
   8869 		    {
   8870 		    dbg.location(939,10);
   8871 		    match(input,COMMA,FOLLOW_COMMA_in_expressionList5025); if (state.failed) return ;
   8872 		    dbg.location(939,14);
   8873 		    pushFollow(FOLLOW_expression_in_expressionList5027);
   8874 		    expression();
   8875 
   8876 		    state._fsp--;
   8877 		    if (state.failed) return ;
   8878 
   8879 		    }
   8880 		    break;
   8881 
   8882 		default :
   8883 		    break loop110;
   8884                 }
   8885             } while (true);
   8886             } finally {dbg.exitSubRule(110);}
   8887 
   8888 
   8889             }
   8890 
   8891         }
   8892         catch (RecognitionException re) {
   8893             reportError(re);
   8894             recover(input,re);
   8895         }
   8896         finally {
   8897             if ( state.backtracking>0 ) { memoize(input, 69, expressionList_StartIndex); }
   8898         }
   8899         dbg.location(941, 5);
   8900 
   8901         }
   8902         finally {
   8903             dbg.exitRule(getGrammarFileName(), "expressionList");
   8904             decRuleLevel();
   8905             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8906         }
   8907 
   8908         return ;
   8909     }
   8910     // $ANTLR end "expressionList"
   8911 
   8912 
   8913     // $ANTLR start "expression"
   8914     // src/com/google/doclava/parser/Java.g:944:1: expression : conditionalExpression ( assignmentOperator expression )? ;
   8915     public final void expression() throws RecognitionException {
   8916         int expression_StartIndex = input.index();
   8917         try { dbg.enterRule(getGrammarFileName(), "expression");
   8918         if ( getRuleLevel()==0 ) {dbg.commence();}
   8919         incRuleLevel();
   8920         dbg.location(944, 1);
   8921 
   8922         try {
   8923             if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return ; }
   8924             // src/com/google/doclava/parser/Java.g:945:5: ( conditionalExpression ( assignmentOperator expression )? )
   8925             dbg.enterAlt(1);
   8926 
   8927             // src/com/google/doclava/parser/Java.g:945:9: conditionalExpression ( assignmentOperator expression )?
   8928             {
   8929             dbg.location(945,9);
   8930             pushFollow(FOLLOW_conditionalExpression_in_expression5058);
   8931             conditionalExpression();
   8932 
   8933             state._fsp--;
   8934             if (state.failed) return ;
   8935             dbg.location(946,9);
   8936             // src/com/google/doclava/parser/Java.g:946:9: ( assignmentOperator expression )?
   8937             int alt111=2;
   8938             try { dbg.enterSubRule(111);
   8939             try { dbg.enterDecision(111, decisionCanBacktrack[111]);
   8940 
   8941             int LA111_0 = input.LA(1);
   8942 
   8943             if ( (LA111_0==EQ||(LA111_0>=PLUSEQ && LA111_0<=PERCENTEQ)||(LA111_0>=GT && LA111_0<=LT)) ) {
   8944                 alt111=1;
   8945             }
   8946             } finally {dbg.exitDecision(111);}
   8947 
   8948             switch (alt111) {
   8949                 case 1 :
   8950                     dbg.enterAlt(1);
   8951 
   8952                     // src/com/google/doclava/parser/Java.g:946:10: assignmentOperator expression
   8953                     {
   8954                     dbg.location(946,10);
   8955                     pushFollow(FOLLOW_assignmentOperator_in_expression5069);
   8956                     assignmentOperator();
   8957 
   8958                     state._fsp--;
   8959                     if (state.failed) return ;
   8960                     dbg.location(946,29);
   8961                     pushFollow(FOLLOW_expression_in_expression5071);
   8962                     expression();
   8963 
   8964                     state._fsp--;
   8965                     if (state.failed) return ;
   8966 
   8967                     }
   8968                     break;
   8969 
   8970             }
   8971             } finally {dbg.exitSubRule(111);}
   8972 
   8973 
   8974             }
   8975 
   8976         }
   8977         catch (RecognitionException re) {
   8978             reportError(re);
   8979             recover(input,re);
   8980         }
   8981         finally {
   8982             if ( state.backtracking>0 ) { memoize(input, 70, expression_StartIndex); }
   8983         }
   8984         dbg.location(948, 5);
   8985 
   8986         }
   8987         finally {
   8988             dbg.exitRule(getGrammarFileName(), "expression");
   8989             decRuleLevel();
   8990             if ( getRuleLevel()==0 ) {dbg.terminate();}
   8991         }
   8992 
   8993         return ;
   8994     }
   8995     // $ANTLR end "expression"
   8996 
   8997 
   8998     // $ANTLR start "assignmentOperator"
   8999     // src/com/google/doclava/parser/Java.g:951:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' );
   9000     public final void assignmentOperator() throws RecognitionException {
   9001         int assignmentOperator_StartIndex = input.index();
   9002         try { dbg.enterRule(getGrammarFileName(), "assignmentOperator");
   9003         if ( getRuleLevel()==0 ) {dbg.commence();}
   9004         incRuleLevel();
   9005         dbg.location(951, 1);
   9006 
   9007         try {
   9008             if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return ; }
   9009             // src/com/google/doclava/parser/Java.g:952:5: ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' )
   9010             int alt112=12;
   9011             try { dbg.enterDecision(112, decisionCanBacktrack[112]);
   9012 
   9013             try {
   9014                 isCyclicDecision = true;
   9015                 alt112 = dfa112.predict(input);
   9016             }
   9017             catch (NoViableAltException nvae) {
   9018                 dbg.recognitionException(nvae);
   9019                 throw nvae;
   9020             }
   9021             } finally {dbg.exitDecision(112);}
   9022 
   9023             switch (alt112) {
   9024                 case 1 :
   9025                     dbg.enterAlt(1);
   9026 
   9027                     // src/com/google/doclava/parser/Java.g:952:9: '='
   9028                     {
   9029                     dbg.location(952,9);
   9030                     match(input,EQ,FOLLOW_EQ_in_assignmentOperator5102); if (state.failed) return ;
   9031 
   9032                     }
   9033                     break;
   9034                 case 2 :
   9035                     dbg.enterAlt(2);
   9036 
   9037                     // src/com/google/doclava/parser/Java.g:953:9: '+='
   9038                     {
   9039                     dbg.location(953,9);
   9040                     match(input,PLUSEQ,FOLLOW_PLUSEQ_in_assignmentOperator5112); if (state.failed) return ;
   9041 
   9042                     }
   9043                     break;
   9044                 case 3 :
   9045                     dbg.enterAlt(3);
   9046 
   9047                     // src/com/google/doclava/parser/Java.g:954:9: '-='
   9048                     {
   9049                     dbg.location(954,9);
   9050                     match(input,SUBEQ,FOLLOW_SUBEQ_in_assignmentOperator5122); if (state.failed) return ;
   9051 
   9052                     }
   9053                     break;
   9054                 case 4 :
   9055                     dbg.enterAlt(4);
   9056 
   9057                     // src/com/google/doclava/parser/Java.g:955:9: '*='
   9058                     {
   9059                     dbg.location(955,9);
   9060                     match(input,STAREQ,FOLLOW_STAREQ_in_assignmentOperator5132); if (state.failed) return ;
   9061 
   9062                     }
   9063                     break;
   9064                 case 5 :
   9065                     dbg.enterAlt(5);
   9066 
   9067                     // src/com/google/doclava/parser/Java.g:956:9: '/='
   9068                     {
   9069                     dbg.location(956,9);
   9070                     match(input,SLASHEQ,FOLLOW_SLASHEQ_in_assignmentOperator5142); if (state.failed) return ;
   9071 
   9072                     }
   9073                     break;
   9074                 case 6 :
   9075                     dbg.enterAlt(6);
   9076 
   9077                     // src/com/google/doclava/parser/Java.g:957:9: '&='
   9078                     {
   9079                     dbg.location(957,9);
   9080                     match(input,AMPEQ,FOLLOW_AMPEQ_in_assignmentOperator5152); if (state.failed) return ;
   9081 
   9082                     }
   9083                     break;
   9084                 case 7 :
   9085                     dbg.enterAlt(7);
   9086 
   9087                     // src/com/google/doclava/parser/Java.g:958:9: '|='
   9088                     {
   9089                     dbg.location(958,9);
   9090                     match(input,BAREQ,FOLLOW_BAREQ_in_assignmentOperator5162); if (state.failed) return ;
   9091 
   9092                     }
   9093                     break;
   9094                 case 8 :
   9095                     dbg.enterAlt(8);
   9096 
   9097                     // src/com/google/doclava/parser/Java.g:959:9: '^='
   9098                     {
   9099                     dbg.location(959,9);
   9100                     match(input,CARETEQ,FOLLOW_CARETEQ_in_assignmentOperator5172); if (state.failed) return ;
   9101 
   9102                     }
   9103                     break;
   9104                 case 9 :
   9105                     dbg.enterAlt(9);
   9106 
   9107                     // src/com/google/doclava/parser/Java.g:960:9: '%='
   9108                     {
   9109                     dbg.location(960,9);
   9110                     match(input,PERCENTEQ,FOLLOW_PERCENTEQ_in_assignmentOperator5182); if (state.failed) return ;
   9111 
   9112                     }
   9113                     break;
   9114                 case 10 :
   9115                     dbg.enterAlt(10);
   9116 
   9117                     // src/com/google/doclava/parser/Java.g:961:10: '<' '<' '='
   9118                     {
   9119                     dbg.location(961,10);
   9120                     match(input,LT,FOLLOW_LT_in_assignmentOperator5193); if (state.failed) return ;
   9121                     dbg.location(961,14);
   9122                     match(input,LT,FOLLOW_LT_in_assignmentOperator5195); if (state.failed) return ;
   9123                     dbg.location(961,18);
   9124                     match(input,EQ,FOLLOW_EQ_in_assignmentOperator5197); if (state.failed) return ;
   9125 
   9126                     }
   9127                     break;
   9128                 case 11 :
   9129                     dbg.enterAlt(11);
   9130 
   9131                     // src/com/google/doclava/parser/Java.g:962:10: '>' '>' '>' '='
   9132                     {
   9133                     dbg.location(962,10);
   9134                     match(input,GT,FOLLOW_GT_in_assignmentOperator5208); if (state.failed) return ;
   9135                     dbg.location(962,14);
   9136                     match(input,GT,FOLLOW_GT_in_assignmentOperator5210); if (state.failed) return ;
   9137                     dbg.location(962,18);
   9138                     match(input,GT,FOLLOW_GT_in_assignmentOperator5212); if (state.failed) return ;
   9139                     dbg.location(962,22);
   9140                     match(input,EQ,FOLLOW_EQ_in_assignmentOperator5214); if (state.failed) return ;
   9141 
   9142                     }
   9143                     break;
   9144                 case 12 :
   9145                     dbg.enterAlt(12);
   9146 
   9147                     // src/com/google/doclava/parser/Java.g:963:10: '>' '>' '='
   9148                     {
   9149                     dbg.location(963,10);
   9150                     match(input,GT,FOLLOW_GT_in_assignmentOperator5225); if (state.failed) return ;
   9151                     dbg.location(963,14);
   9152                     match(input,GT,FOLLOW_GT_in_assignmentOperator5227); if (state.failed) return ;
   9153                     dbg.location(963,18);
   9154                     match(input,EQ,FOLLOW_EQ_in_assignmentOperator5229); if (state.failed) return ;
   9155 
   9156                     }
   9157                     break;
   9158 
   9159             }
   9160         }
   9161         catch (RecognitionException re) {
   9162             reportError(re);
   9163             recover(input,re);
   9164         }
   9165         finally {
   9166             if ( state.backtracking>0 ) { memoize(input, 71, assignmentOperator_StartIndex); }
   9167         }
   9168         dbg.location(964, 5);
   9169 
   9170         }
   9171         finally {
   9172             dbg.exitRule(getGrammarFileName(), "assignmentOperator");
   9173             decRuleLevel();
   9174             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9175         }
   9176 
   9177         return ;
   9178     }
   9179     // $ANTLR end "assignmentOperator"
   9180 
   9181 
   9182     // $ANTLR start "conditionalExpression"
   9183     // src/com/google/doclava/parser/Java.g:967:1: conditionalExpression : conditionalOrExpression ( '?' expression ':' conditionalExpression )? ;
   9184     public final void conditionalExpression() throws RecognitionException {
   9185         int conditionalExpression_StartIndex = input.index();
   9186         try { dbg.enterRule(getGrammarFileName(), "conditionalExpression");
   9187         if ( getRuleLevel()==0 ) {dbg.commence();}
   9188         incRuleLevel();
   9189         dbg.location(967, 1);
   9190 
   9191         try {
   9192             if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return ; }
   9193             // src/com/google/doclava/parser/Java.g:968:5: ( conditionalOrExpression ( '?' expression ':' conditionalExpression )? )
   9194             dbg.enterAlt(1);
   9195 
   9196             // src/com/google/doclava/parser/Java.g:968:9: conditionalOrExpression ( '?' expression ':' conditionalExpression )?
   9197             {
   9198             dbg.location(968,9);
   9199             pushFollow(FOLLOW_conditionalOrExpression_in_conditionalExpression5249);
   9200             conditionalOrExpression();
   9201 
   9202             state._fsp--;
   9203             if (state.failed) return ;
   9204             dbg.location(969,9);
   9205             // src/com/google/doclava/parser/Java.g:969:9: ( '?' expression ':' conditionalExpression )?
   9206             int alt113=2;
   9207             try { dbg.enterSubRule(113);
   9208             try { dbg.enterDecision(113, decisionCanBacktrack[113]);
   9209 
   9210             int LA113_0 = input.LA(1);
   9211 
   9212             if ( (LA113_0==QUES) ) {
   9213                 alt113=1;
   9214             }
   9215             } finally {dbg.exitDecision(113);}
   9216 
   9217             switch (alt113) {
   9218                 case 1 :
   9219                     dbg.enterAlt(1);
   9220 
   9221                     // src/com/google/doclava/parser/Java.g:969:10: '?' expression ':' conditionalExpression
   9222                     {
   9223                     dbg.location(969,10);
   9224                     match(input,QUES,FOLLOW_QUES_in_conditionalExpression5260); if (state.failed) return ;
   9225                     dbg.location(969,14);
   9226                     pushFollow(FOLLOW_expression_in_conditionalExpression5262);
   9227                     expression();
   9228 
   9229                     state._fsp--;
   9230                     if (state.failed) return ;
   9231                     dbg.location(969,25);
   9232                     match(input,COLON,FOLLOW_COLON_in_conditionalExpression5264); if (state.failed) return ;
   9233                     dbg.location(969,29);
   9234                     pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression5266);
   9235                     conditionalExpression();
   9236 
   9237                     state._fsp--;
   9238                     if (state.failed) return ;
   9239 
   9240                     }
   9241                     break;
   9242 
   9243             }
   9244             } finally {dbg.exitSubRule(113);}
   9245 
   9246 
   9247             }
   9248 
   9249         }
   9250         catch (RecognitionException re) {
   9251             reportError(re);
   9252             recover(input,re);
   9253         }
   9254         finally {
   9255             if ( state.backtracking>0 ) { memoize(input, 72, conditionalExpression_StartIndex); }
   9256         }
   9257         dbg.location(971, 5);
   9258 
   9259         }
   9260         finally {
   9261             dbg.exitRule(getGrammarFileName(), "conditionalExpression");
   9262             decRuleLevel();
   9263             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9264         }
   9265 
   9266         return ;
   9267     }
   9268     // $ANTLR end "conditionalExpression"
   9269 
   9270 
   9271     // $ANTLR start "conditionalOrExpression"
   9272     // src/com/google/doclava/parser/Java.g:973:1: conditionalOrExpression : conditionalAndExpression ( '||' conditionalAndExpression )* ;
   9273     public final void conditionalOrExpression() throws RecognitionException {
   9274         int conditionalOrExpression_StartIndex = input.index();
   9275         try { dbg.enterRule(getGrammarFileName(), "conditionalOrExpression");
   9276         if ( getRuleLevel()==0 ) {dbg.commence();}
   9277         incRuleLevel();
   9278         dbg.location(973, 1);
   9279 
   9280         try {
   9281             if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return ; }
   9282             // src/com/google/doclava/parser/Java.g:974:5: ( conditionalAndExpression ( '||' conditionalAndExpression )* )
   9283             dbg.enterAlt(1);
   9284 
   9285             // src/com/google/doclava/parser/Java.g:974:9: conditionalAndExpression ( '||' conditionalAndExpression )*
   9286             {
   9287             dbg.location(974,9);
   9288             pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression5296);
   9289             conditionalAndExpression();
   9290 
   9291             state._fsp--;
   9292             if (state.failed) return ;
   9293             dbg.location(975,9);
   9294             // src/com/google/doclava/parser/Java.g:975:9: ( '||' conditionalAndExpression )*
   9295             try { dbg.enterSubRule(114);
   9296 
   9297             loop114:
   9298             do {
   9299                 int alt114=2;
   9300                 try { dbg.enterDecision(114, decisionCanBacktrack[114]);
   9301 
   9302                 int LA114_0 = input.LA(1);
   9303 
   9304                 if ( (LA114_0==BARBAR) ) {
   9305                     alt114=1;
   9306                 }
   9307 
   9308 
   9309                 } finally {dbg.exitDecision(114);}
   9310 
   9311                 switch (alt114) {
   9312 		case 1 :
   9313 		    dbg.enterAlt(1);
   9314 
   9315 		    // src/com/google/doclava/parser/Java.g:975:10: '||' conditionalAndExpression
   9316 		    {
   9317 		    dbg.location(975,10);
   9318 		    match(input,BARBAR,FOLLOW_BARBAR_in_conditionalOrExpression5307); if (state.failed) return ;
   9319 		    dbg.location(975,15);
   9320 		    pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression5309);
   9321 		    conditionalAndExpression();
   9322 
   9323 		    state._fsp--;
   9324 		    if (state.failed) return ;
   9325 
   9326 		    }
   9327 		    break;
   9328 
   9329 		default :
   9330 		    break loop114;
   9331                 }
   9332             } while (true);
   9333             } finally {dbg.exitSubRule(114);}
   9334 
   9335 
   9336             }
   9337 
   9338         }
   9339         catch (RecognitionException re) {
   9340             reportError(re);
   9341             recover(input,re);
   9342         }
   9343         finally {
   9344             if ( state.backtracking>0 ) { memoize(input, 73, conditionalOrExpression_StartIndex); }
   9345         }
   9346         dbg.location(977, 5);
   9347 
   9348         }
   9349         finally {
   9350             dbg.exitRule(getGrammarFileName(), "conditionalOrExpression");
   9351             decRuleLevel();
   9352             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9353         }
   9354 
   9355         return ;
   9356     }
   9357     // $ANTLR end "conditionalOrExpression"
   9358 
   9359 
   9360     // $ANTLR start "conditionalAndExpression"
   9361     // src/com/google/doclava/parser/Java.g:979:1: conditionalAndExpression : inclusiveOrExpression ( '&&' inclusiveOrExpression )* ;
   9362     public final void conditionalAndExpression() throws RecognitionException {
   9363         int conditionalAndExpression_StartIndex = input.index();
   9364         try { dbg.enterRule(getGrammarFileName(), "conditionalAndExpression");
   9365         if ( getRuleLevel()==0 ) {dbg.commence();}
   9366         incRuleLevel();
   9367         dbg.location(979, 1);
   9368 
   9369         try {
   9370             if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return ; }
   9371             // src/com/google/doclava/parser/Java.g:980:5: ( inclusiveOrExpression ( '&&' inclusiveOrExpression )* )
   9372             dbg.enterAlt(1);
   9373 
   9374             // src/com/google/doclava/parser/Java.g:980:9: inclusiveOrExpression ( '&&' inclusiveOrExpression )*
   9375             {
   9376             dbg.location(980,9);
   9377             pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5339);
   9378             inclusiveOrExpression();
   9379 
   9380             state._fsp--;
   9381             if (state.failed) return ;
   9382             dbg.location(981,9);
   9383             // src/com/google/doclava/parser/Java.g:981:9: ( '&&' inclusiveOrExpression )*
   9384             try { dbg.enterSubRule(115);
   9385 
   9386             loop115:
   9387             do {
   9388                 int alt115=2;
   9389                 try { dbg.enterDecision(115, decisionCanBacktrack[115]);
   9390 
   9391                 int LA115_0 = input.LA(1);
   9392 
   9393                 if ( (LA115_0==AMPAMP) ) {
   9394                     alt115=1;
   9395                 }
   9396 
   9397 
   9398                 } finally {dbg.exitDecision(115);}
   9399 
   9400                 switch (alt115) {
   9401 		case 1 :
   9402 		    dbg.enterAlt(1);
   9403 
   9404 		    // src/com/google/doclava/parser/Java.g:981:10: '&&' inclusiveOrExpression
   9405 		    {
   9406 		    dbg.location(981,10);
   9407 		    match(input,AMPAMP,FOLLOW_AMPAMP_in_conditionalAndExpression5350); if (state.failed) return ;
   9408 		    dbg.location(981,15);
   9409 		    pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5352);
   9410 		    inclusiveOrExpression();
   9411 
   9412 		    state._fsp--;
   9413 		    if (state.failed) return ;
   9414 
   9415 		    }
   9416 		    break;
   9417 
   9418 		default :
   9419 		    break loop115;
   9420                 }
   9421             } while (true);
   9422             } finally {dbg.exitSubRule(115);}
   9423 
   9424 
   9425             }
   9426 
   9427         }
   9428         catch (RecognitionException re) {
   9429             reportError(re);
   9430             recover(input,re);
   9431         }
   9432         finally {
   9433             if ( state.backtracking>0 ) { memoize(input, 74, conditionalAndExpression_StartIndex); }
   9434         }
   9435         dbg.location(983, 5);
   9436 
   9437         }
   9438         finally {
   9439             dbg.exitRule(getGrammarFileName(), "conditionalAndExpression");
   9440             decRuleLevel();
   9441             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9442         }
   9443 
   9444         return ;
   9445     }
   9446     // $ANTLR end "conditionalAndExpression"
   9447 
   9448 
   9449     // $ANTLR start "inclusiveOrExpression"
   9450     // src/com/google/doclava/parser/Java.g:985:1: inclusiveOrExpression : exclusiveOrExpression ( '|' exclusiveOrExpression )* ;
   9451     public final void inclusiveOrExpression() throws RecognitionException {
   9452         int inclusiveOrExpression_StartIndex = input.index();
   9453         try { dbg.enterRule(getGrammarFileName(), "inclusiveOrExpression");
   9454         if ( getRuleLevel()==0 ) {dbg.commence();}
   9455         incRuleLevel();
   9456         dbg.location(985, 1);
   9457 
   9458         try {
   9459             if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return ; }
   9460             // src/com/google/doclava/parser/Java.g:986:5: ( exclusiveOrExpression ( '|' exclusiveOrExpression )* )
   9461             dbg.enterAlt(1);
   9462 
   9463             // src/com/google/doclava/parser/Java.g:986:9: exclusiveOrExpression ( '|' exclusiveOrExpression )*
   9464             {
   9465             dbg.location(986,9);
   9466             pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5382);
   9467             exclusiveOrExpression();
   9468 
   9469             state._fsp--;
   9470             if (state.failed) return ;
   9471             dbg.location(987,9);
   9472             // src/com/google/doclava/parser/Java.g:987:9: ( '|' exclusiveOrExpression )*
   9473             try { dbg.enterSubRule(116);
   9474 
   9475             loop116:
   9476             do {
   9477                 int alt116=2;
   9478                 try { dbg.enterDecision(116, decisionCanBacktrack[116]);
   9479 
   9480                 int LA116_0 = input.LA(1);
   9481 
   9482                 if ( (LA116_0==BAR) ) {
   9483                     alt116=1;
   9484                 }
   9485 
   9486 
   9487                 } finally {dbg.exitDecision(116);}
   9488 
   9489                 switch (alt116) {
   9490 		case 1 :
   9491 		    dbg.enterAlt(1);
   9492 
   9493 		    // src/com/google/doclava/parser/Java.g:987:10: '|' exclusiveOrExpression
   9494 		    {
   9495 		    dbg.location(987,10);
   9496 		    match(input,BAR,FOLLOW_BAR_in_inclusiveOrExpression5393); if (state.failed) return ;
   9497 		    dbg.location(987,14);
   9498 		    pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5395);
   9499 		    exclusiveOrExpression();
   9500 
   9501 		    state._fsp--;
   9502 		    if (state.failed) return ;
   9503 
   9504 		    }
   9505 		    break;
   9506 
   9507 		default :
   9508 		    break loop116;
   9509                 }
   9510             } while (true);
   9511             } finally {dbg.exitSubRule(116);}
   9512 
   9513 
   9514             }
   9515 
   9516         }
   9517         catch (RecognitionException re) {
   9518             reportError(re);
   9519             recover(input,re);
   9520         }
   9521         finally {
   9522             if ( state.backtracking>0 ) { memoize(input, 75, inclusiveOrExpression_StartIndex); }
   9523         }
   9524         dbg.location(989, 5);
   9525 
   9526         }
   9527         finally {
   9528             dbg.exitRule(getGrammarFileName(), "inclusiveOrExpression");
   9529             decRuleLevel();
   9530             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9531         }
   9532 
   9533         return ;
   9534     }
   9535     // $ANTLR end "inclusiveOrExpression"
   9536 
   9537 
   9538     // $ANTLR start "exclusiveOrExpression"
   9539     // src/com/google/doclava/parser/Java.g:991:1: exclusiveOrExpression : andExpression ( '^' andExpression )* ;
   9540     public final void exclusiveOrExpression() throws RecognitionException {
   9541         int exclusiveOrExpression_StartIndex = input.index();
   9542         try { dbg.enterRule(getGrammarFileName(), "exclusiveOrExpression");
   9543         if ( getRuleLevel()==0 ) {dbg.commence();}
   9544         incRuleLevel();
   9545         dbg.location(991, 1);
   9546 
   9547         try {
   9548             if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return ; }
   9549             // src/com/google/doclava/parser/Java.g:992:5: ( andExpression ( '^' andExpression )* )
   9550             dbg.enterAlt(1);
   9551 
   9552             // src/com/google/doclava/parser/Java.g:992:9: andExpression ( '^' andExpression )*
   9553             {
   9554             dbg.location(992,9);
   9555             pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression5425);
   9556             andExpression();
   9557 
   9558             state._fsp--;
   9559             if (state.failed) return ;
   9560             dbg.location(993,9);
   9561             // src/com/google/doclava/parser/Java.g:993:9: ( '^' andExpression )*
   9562             try { dbg.enterSubRule(117);
   9563 
   9564             loop117:
   9565             do {
   9566                 int alt117=2;
   9567                 try { dbg.enterDecision(117, decisionCanBacktrack[117]);
   9568 
   9569                 int LA117_0 = input.LA(1);
   9570 
   9571                 if ( (LA117_0==CARET) ) {
   9572                     alt117=1;
   9573                 }
   9574 
   9575 
   9576                 } finally {dbg.exitDecision(117);}
   9577 
   9578                 switch (alt117) {
   9579 		case 1 :
   9580 		    dbg.enterAlt(1);
   9581 
   9582 		    // src/com/google/doclava/parser/Java.g:993:10: '^' andExpression
   9583 		    {
   9584 		    dbg.location(993,10);
   9585 		    match(input,CARET,FOLLOW_CARET_in_exclusiveOrExpression5436); if (state.failed) return ;
   9586 		    dbg.location(993,14);
   9587 		    pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression5438);
   9588 		    andExpression();
   9589 
   9590 		    state._fsp--;
   9591 		    if (state.failed) return ;
   9592 
   9593 		    }
   9594 		    break;
   9595 
   9596 		default :
   9597 		    break loop117;
   9598                 }
   9599             } while (true);
   9600             } finally {dbg.exitSubRule(117);}
   9601 
   9602 
   9603             }
   9604 
   9605         }
   9606         catch (RecognitionException re) {
   9607             reportError(re);
   9608             recover(input,re);
   9609         }
   9610         finally {
   9611             if ( state.backtracking>0 ) { memoize(input, 76, exclusiveOrExpression_StartIndex); }
   9612         }
   9613         dbg.location(995, 5);
   9614 
   9615         }
   9616         finally {
   9617             dbg.exitRule(getGrammarFileName(), "exclusiveOrExpression");
   9618             decRuleLevel();
   9619             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9620         }
   9621 
   9622         return ;
   9623     }
   9624     // $ANTLR end "exclusiveOrExpression"
   9625 
   9626 
   9627     // $ANTLR start "andExpression"
   9628     // src/com/google/doclava/parser/Java.g:997:1: andExpression : equalityExpression ( '&' equalityExpression )* ;
   9629     public final void andExpression() throws RecognitionException {
   9630         int andExpression_StartIndex = input.index();
   9631         try { dbg.enterRule(getGrammarFileName(), "andExpression");
   9632         if ( getRuleLevel()==0 ) {dbg.commence();}
   9633         incRuleLevel();
   9634         dbg.location(997, 1);
   9635 
   9636         try {
   9637             if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return ; }
   9638             // src/com/google/doclava/parser/Java.g:998:5: ( equalityExpression ( '&' equalityExpression )* )
   9639             dbg.enterAlt(1);
   9640 
   9641             // src/com/google/doclava/parser/Java.g:998:9: equalityExpression ( '&' equalityExpression )*
   9642             {
   9643             dbg.location(998,9);
   9644             pushFollow(FOLLOW_equalityExpression_in_andExpression5468);
   9645             equalityExpression();
   9646 
   9647             state._fsp--;
   9648             if (state.failed) return ;
   9649             dbg.location(999,9);
   9650             // src/com/google/doclava/parser/Java.g:999:9: ( '&' equalityExpression )*
   9651             try { dbg.enterSubRule(118);
   9652 
   9653             loop118:
   9654             do {
   9655                 int alt118=2;
   9656                 try { dbg.enterDecision(118, decisionCanBacktrack[118]);
   9657 
   9658                 int LA118_0 = input.LA(1);
   9659 
   9660                 if ( (LA118_0==AMP) ) {
   9661                     alt118=1;
   9662                 }
   9663 
   9664 
   9665                 } finally {dbg.exitDecision(118);}
   9666 
   9667                 switch (alt118) {
   9668 		case 1 :
   9669 		    dbg.enterAlt(1);
   9670 
   9671 		    // src/com/google/doclava/parser/Java.g:999:10: '&' equalityExpression
   9672 		    {
   9673 		    dbg.location(999,10);
   9674 		    match(input,AMP,FOLLOW_AMP_in_andExpression5479); if (state.failed) return ;
   9675 		    dbg.location(999,14);
   9676 		    pushFollow(FOLLOW_equalityExpression_in_andExpression5481);
   9677 		    equalityExpression();
   9678 
   9679 		    state._fsp--;
   9680 		    if (state.failed) return ;
   9681 
   9682 		    }
   9683 		    break;
   9684 
   9685 		default :
   9686 		    break loop118;
   9687                 }
   9688             } while (true);
   9689             } finally {dbg.exitSubRule(118);}
   9690 
   9691 
   9692             }
   9693 
   9694         }
   9695         catch (RecognitionException re) {
   9696             reportError(re);
   9697             recover(input,re);
   9698         }
   9699         finally {
   9700             if ( state.backtracking>0 ) { memoize(input, 77, andExpression_StartIndex); }
   9701         }
   9702         dbg.location(1001, 5);
   9703 
   9704         }
   9705         finally {
   9706             dbg.exitRule(getGrammarFileName(), "andExpression");
   9707             decRuleLevel();
   9708             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9709         }
   9710 
   9711         return ;
   9712     }
   9713     // $ANTLR end "andExpression"
   9714 
   9715 
   9716     // $ANTLR start "equalityExpression"
   9717     // src/com/google/doclava/parser/Java.g:1003:1: equalityExpression : instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* ;
   9718     public final void equalityExpression() throws RecognitionException {
   9719         int equalityExpression_StartIndex = input.index();
   9720         try { dbg.enterRule(getGrammarFileName(), "equalityExpression");
   9721         if ( getRuleLevel()==0 ) {dbg.commence();}
   9722         incRuleLevel();
   9723         dbg.location(1003, 1);
   9724 
   9725         try {
   9726             if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return ; }
   9727             // src/com/google/doclava/parser/Java.g:1004:5: ( instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* )
   9728             dbg.enterAlt(1);
   9729 
   9730             // src/com/google/doclava/parser/Java.g:1004:9: instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )*
   9731             {
   9732             dbg.location(1004,9);
   9733             pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression5511);
   9734             instanceOfExpression();
   9735 
   9736             state._fsp--;
   9737             if (state.failed) return ;
   9738             dbg.location(1005,9);
   9739             // src/com/google/doclava/parser/Java.g:1005:9: ( ( '==' | '!=' ) instanceOfExpression )*
   9740             try { dbg.enterSubRule(119);
   9741 
   9742             loop119:
   9743             do {
   9744                 int alt119=2;
   9745                 try { dbg.enterDecision(119, decisionCanBacktrack[119]);
   9746 
   9747                 int LA119_0 = input.LA(1);
   9748 
   9749                 if ( (LA119_0==EQEQ||LA119_0==BANGEQ) ) {
   9750                     alt119=1;
   9751                 }
   9752 
   9753 
   9754                 } finally {dbg.exitDecision(119);}
   9755 
   9756                 switch (alt119) {
   9757 		case 1 :
   9758 		    dbg.enterAlt(1);
   9759 
   9760 		    // src/com/google/doclava/parser/Java.g:1006:13: ( '==' | '!=' ) instanceOfExpression
   9761 		    {
   9762 		    dbg.location(1006,13);
   9763 		    if ( input.LA(1)==EQEQ||input.LA(1)==BANGEQ ) {
   9764 		        input.consume();
   9765 		        state.errorRecovery=false;state.failed=false;
   9766 		    }
   9767 		    else {
   9768 		        if (state.backtracking>0) {state.failed=true; return ;}
   9769 		        MismatchedSetException mse = new MismatchedSetException(null,input);
   9770 		        dbg.recognitionException(mse);
   9771 		        throw mse;
   9772 		    }
   9773 
   9774 		    dbg.location(1009,13);
   9775 		    pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression5585);
   9776 		    instanceOfExpression();
   9777 
   9778 		    state._fsp--;
   9779 		    if (state.failed) return ;
   9780 
   9781 		    }
   9782 		    break;
   9783 
   9784 		default :
   9785 		    break loop119;
   9786                 }
   9787             } while (true);
   9788             } finally {dbg.exitSubRule(119);}
   9789 
   9790 
   9791             }
   9792 
   9793         }
   9794         catch (RecognitionException re) {
   9795             reportError(re);
   9796             recover(input,re);
   9797         }
   9798         finally {
   9799             if ( state.backtracking>0 ) { memoize(input, 78, equalityExpression_StartIndex); }
   9800         }
   9801         dbg.location(1011, 5);
   9802 
   9803         }
   9804         finally {
   9805             dbg.exitRule(getGrammarFileName(), "equalityExpression");
   9806             decRuleLevel();
   9807             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9808         }
   9809 
   9810         return ;
   9811     }
   9812     // $ANTLR end "equalityExpression"
   9813 
   9814 
   9815     // $ANTLR start "instanceOfExpression"
   9816     // src/com/google/doclava/parser/Java.g:1013:1: instanceOfExpression : relationalExpression ( 'instanceof' type )? ;
   9817     public final void instanceOfExpression() throws RecognitionException {
   9818         int instanceOfExpression_StartIndex = input.index();
   9819         try { dbg.enterRule(getGrammarFileName(), "instanceOfExpression");
   9820         if ( getRuleLevel()==0 ) {dbg.commence();}
   9821         incRuleLevel();
   9822         dbg.location(1013, 1);
   9823 
   9824         try {
   9825             if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return ; }
   9826             // src/com/google/doclava/parser/Java.g:1014:5: ( relationalExpression ( 'instanceof' type )? )
   9827             dbg.enterAlt(1);
   9828 
   9829             // src/com/google/doclava/parser/Java.g:1014:9: relationalExpression ( 'instanceof' type )?
   9830             {
   9831             dbg.location(1014,9);
   9832             pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression5615);
   9833             relationalExpression();
   9834 
   9835             state._fsp--;
   9836             if (state.failed) return ;
   9837             dbg.location(1015,9);
   9838             // src/com/google/doclava/parser/Java.g:1015:9: ( 'instanceof' type )?
   9839             int alt120=2;
   9840             try { dbg.enterSubRule(120);
   9841             try { dbg.enterDecision(120, decisionCanBacktrack[120]);
   9842 
   9843             int LA120_0 = input.LA(1);
   9844 
   9845             if ( (LA120_0==INSTANCEOF) ) {
   9846                 alt120=1;
   9847             }
   9848             } finally {dbg.exitDecision(120);}
   9849 
   9850             switch (alt120) {
   9851                 case 1 :
   9852                     dbg.enterAlt(1);
   9853 
   9854                     // src/com/google/doclava/parser/Java.g:1015:10: 'instanceof' type
   9855                     {
   9856                     dbg.location(1015,10);
   9857                     match(input,INSTANCEOF,FOLLOW_INSTANCEOF_in_instanceOfExpression5626); if (state.failed) return ;
   9858                     dbg.location(1015,23);
   9859                     pushFollow(FOLLOW_type_in_instanceOfExpression5628);
   9860                     type();
   9861 
   9862                     state._fsp--;
   9863                     if (state.failed) return ;
   9864 
   9865                     }
   9866                     break;
   9867 
   9868             }
   9869             } finally {dbg.exitSubRule(120);}
   9870 
   9871 
   9872             }
   9873 
   9874         }
   9875         catch (RecognitionException re) {
   9876             reportError(re);
   9877             recover(input,re);
   9878         }
   9879         finally {
   9880             if ( state.backtracking>0 ) { memoize(input, 79, instanceOfExpression_StartIndex); }
   9881         }
   9882         dbg.location(1017, 5);
   9883 
   9884         }
   9885         finally {
   9886             dbg.exitRule(getGrammarFileName(), "instanceOfExpression");
   9887             decRuleLevel();
   9888             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9889         }
   9890 
   9891         return ;
   9892     }
   9893     // $ANTLR end "instanceOfExpression"
   9894 
   9895 
   9896     // $ANTLR start "relationalExpression"
   9897     // src/com/google/doclava/parser/Java.g:1019:1: relationalExpression : shiftExpression ( relationalOp shiftExpression )* ;
   9898     public final void relationalExpression() throws RecognitionException {
   9899         int relationalExpression_StartIndex = input.index();
   9900         try { dbg.enterRule(getGrammarFileName(), "relationalExpression");
   9901         if ( getRuleLevel()==0 ) {dbg.commence();}
   9902         incRuleLevel();
   9903         dbg.location(1019, 1);
   9904 
   9905         try {
   9906             if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return ; }
   9907             // src/com/google/doclava/parser/Java.g:1020:5: ( shiftExpression ( relationalOp shiftExpression )* )
   9908             dbg.enterAlt(1);
   9909 
   9910             // src/com/google/doclava/parser/Java.g:1020:9: shiftExpression ( relationalOp shiftExpression )*
   9911             {
   9912             dbg.location(1020,9);
   9913             pushFollow(FOLLOW_shiftExpression_in_relationalExpression5658);
   9914             shiftExpression();
   9915 
   9916             state._fsp--;
   9917             if (state.failed) return ;
   9918             dbg.location(1021,9);
   9919             // src/com/google/doclava/parser/Java.g:1021:9: ( relationalOp shiftExpression )*
   9920             try { dbg.enterSubRule(121);
   9921 
   9922             loop121:
   9923             do {
   9924                 int alt121=2;
   9925                 try { dbg.enterDecision(121, decisionCanBacktrack[121]);
   9926 
   9927                 int LA121_0 = input.LA(1);
   9928 
   9929                 if ( (LA121_0==LT) ) {
   9930                     int LA121_2 = input.LA(2);
   9931 
   9932                     if ( ((LA121_2>=IDENTIFIER && LA121_2<=NULL)||LA121_2==BOOLEAN||LA121_2==BYTE||LA121_2==CHAR||LA121_2==DOUBLE||LA121_2==FLOAT||LA121_2==INT||LA121_2==LONG||LA121_2==NEW||LA121_2==SHORT||LA121_2==SUPER||LA121_2==THIS||LA121_2==VOID||LA121_2==LPAREN||(LA121_2>=EQ && LA121_2<=TILDE)||(LA121_2>=PLUSPLUS && LA121_2<=SUB)) ) {
   9933                         alt121=1;
   9934                     }
   9935 
   9936 
   9937                 }
   9938                 else if ( (LA121_0==GT) ) {
   9939                     int LA121_3 = input.LA(2);
   9940 
   9941                     if ( ((LA121_3>=IDENTIFIER && LA121_3<=NULL)||LA121_3==BOOLEAN||LA121_3==BYTE||LA121_3==CHAR||LA121_3==DOUBLE||LA121_3==FLOAT||LA121_3==INT||LA121_3==LONG||LA121_3==NEW||LA121_3==SHORT||LA121_3==SUPER||LA121_3==THIS||LA121_3==VOID||LA121_3==LPAREN||(LA121_3>=EQ && LA121_3<=TILDE)||(LA121_3>=PLUSPLUS && LA121_3<=SUB)) ) {
   9942                         alt121=1;
   9943                     }
   9944 
   9945 
   9946                 }
   9947 
   9948 
   9949                 } finally {dbg.exitDecision(121);}
   9950 
   9951                 switch (alt121) {
   9952 		case 1 :
   9953 		    dbg.enterAlt(1);
   9954 
   9955 		    // src/com/google/doclava/parser/Java.g:1021:10: relationalOp shiftExpression
   9956 		    {
   9957 		    dbg.location(1021,10);
   9958 		    pushFollow(FOLLOW_relationalOp_in_relationalExpression5669);
   9959 		    relationalOp();
   9960 
   9961 		    state._fsp--;
   9962 		    if (state.failed) return ;
   9963 		    dbg.location(1021,23);
   9964 		    pushFollow(FOLLOW_shiftExpression_in_relationalExpression5671);
   9965 		    shiftExpression();
   9966 
   9967 		    state._fsp--;
   9968 		    if (state.failed) return ;
   9969 
   9970 		    }
   9971 		    break;
   9972 
   9973 		default :
   9974 		    break loop121;
   9975                 }
   9976             } while (true);
   9977             } finally {dbg.exitSubRule(121);}
   9978 
   9979 
   9980             }
   9981 
   9982         }
   9983         catch (RecognitionException re) {
   9984             reportError(re);
   9985             recover(input,re);
   9986         }
   9987         finally {
   9988             if ( state.backtracking>0 ) { memoize(input, 80, relationalExpression_StartIndex); }
   9989         }
   9990         dbg.location(1023, 5);
   9991 
   9992         }
   9993         finally {
   9994             dbg.exitRule(getGrammarFileName(), "relationalExpression");
   9995             decRuleLevel();
   9996             if ( getRuleLevel()==0 ) {dbg.terminate();}
   9997         }
   9998 
   9999         return ;
   10000     }
   10001     // $ANTLR end "relationalExpression"
   10002 
   10003 
   10004     // $ANTLR start "relationalOp"
   10005     // src/com/google/doclava/parser/Java.g:1025:1: relationalOp : ( '<' '=' | '>' '=' | '<' | '>' );
   10006     public final void relationalOp() throws RecognitionException {
   10007         int relationalOp_StartIndex = input.index();
   10008         try { dbg.enterRule(getGrammarFileName(), "relationalOp");
   10009         if ( getRuleLevel()==0 ) {dbg.commence();}
   10010         incRuleLevel();
   10011         dbg.location(1025, 1);
   10012 
   10013         try {
   10014             if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return ; }
   10015             // src/com/google/doclava/parser/Java.g:1026:5: ( '<' '=' | '>' '=' | '<' | '>' )
   10016             int alt122=4;
   10017             try { dbg.enterDecision(122, decisionCanBacktrack[122]);
   10018 
   10019             int LA122_0 = input.LA(1);
   10020 
   10021             if ( (LA122_0==LT) ) {
   10022                 int LA122_1 = input.LA(2);
   10023 
   10024                 if ( (LA122_1==EQ) ) {
   10025                     alt122=1;
   10026                 }
   10027                 else if ( ((LA122_1>=IDENTIFIER && LA122_1<=NULL)||LA122_1==BOOLEAN||LA122_1==BYTE||LA122_1==CHAR||LA122_1==DOUBLE||LA122_1==FLOAT||LA122_1==INT||LA122_1==LONG||LA122_1==NEW||LA122_1==SHORT||LA122_1==SUPER||LA122_1==THIS||LA122_1==VOID||LA122_1==LPAREN||(LA122_1>=BANG && LA122_1<=TILDE)||(LA122_1>=PLUSPLUS && LA122_1<=SUB)) ) {
   10028                     alt122=3;
   10029                 }
   10030                 else {
   10031                     if (state.backtracking>0) {state.failed=true; return ;}
   10032                     NoViableAltException nvae =
   10033                         new NoViableAltException("", 122, 1, input);
   10034 
   10035                     dbg.recognitionException(nvae);
   10036                     throw nvae;
   10037                 }
   10038             }
   10039             else if ( (LA122_0==GT) ) {
   10040                 int LA122_2 = input.LA(2);
   10041 
   10042                 if ( (LA122_2==EQ) ) {
   10043                     alt122=2;
   10044                 }
   10045                 else if ( ((LA122_2>=IDENTIFIER && LA122_2<=NULL)||LA122_2==BOOLEAN||LA122_2==BYTE||LA122_2==CHAR||LA122_2==DOUBLE||LA122_2==FLOAT||LA122_2==INT||LA122_2==LONG||LA122_2==NEW||LA122_2==SHORT||LA122_2==SUPER||LA122_2==THIS||LA122_2==VOID||LA122_2==LPAREN||(LA122_2>=BANG && LA122_2<=TILDE)||(LA122_2>=PLUSPLUS && LA122_2<=SUB)) ) {
   10046                     alt122=4;
   10047                 }
   10048                 else {
   10049                     if (state.backtracking>0) {state.failed=true; return ;}
   10050                     NoViableAltException nvae =
   10051                         new NoViableAltException("", 122, 2, input);
   10052 
   10053                     dbg.recognitionException(nvae);
   10054                     throw nvae;
   10055                 }
   10056             }
   10057             else {
   10058                 if (state.backtracking>0) {state.failed=true; return ;}
   10059                 NoViableAltException nvae =
   10060                     new NoViableAltException("", 122, 0, input);
   10061 
   10062                 dbg.recognitionException(nvae);
   10063                 throw nvae;
   10064             }
   10065             } finally {dbg.exitDecision(122);}
   10066 
   10067             switch (alt122) {
   10068                 case 1 :
   10069                     dbg.enterAlt(1);
   10070 
   10071                     // src/com/google/doclava/parser/Java.g:1026:10: '<' '='
   10072                     {
   10073                     dbg.location(1026,10);
   10074                     match(input,LT,FOLLOW_LT_in_relationalOp5702); if (state.failed) return ;
   10075                     dbg.location(1026,14);
   10076                     match(input,EQ,FOLLOW_EQ_in_relationalOp5704); if (state.failed) return ;
   10077 
   10078                     }
   10079                     break;
   10080                 case 2 :
   10081                     dbg.enterAlt(2);
   10082 
   10083                     // src/com/google/doclava/parser/Java.g:1027:10: '>' '='
   10084                     {
   10085                     dbg.location(1027,10);
   10086                     match(input,GT,FOLLOW_GT_in_relationalOp5715); if (state.failed) return ;
   10087                     dbg.location(1027,14);
   10088                     match(input,EQ,FOLLOW_EQ_in_relationalOp5717); if (state.failed) return ;
   10089 
   10090                     }
   10091                     break;
   10092                 case 3 :
   10093                     dbg.enterAlt(3);
   10094 
   10095                     // src/com/google/doclava/parser/Java.g:1028:9: '<'
   10096                     {
   10097                     dbg.location(1028,9);
   10098                     match(input,LT,FOLLOW_LT_in_relationalOp5727); if (state.failed) return ;
   10099 
   10100                     }
   10101                     break;
   10102                 case 4 :
   10103                     dbg.enterAlt(4);
   10104 
   10105                     // src/com/google/doclava/parser/Java.g:1029:9: '>'
   10106                     {
   10107                     dbg.location(1029,9);
   10108                     match(input,GT,FOLLOW_GT_in_relationalOp5737); if (state.failed) return ;
   10109 
   10110                     }
   10111                     break;
   10112 
   10113             }
   10114         }
   10115         catch (RecognitionException re) {
   10116             reportError(re);
   10117             recover(input,re);
   10118         }
   10119         finally {
   10120             if ( state.backtracking>0 ) { memoize(input, 81, relationalOp_StartIndex); }
   10121         }
   10122         dbg.location(1030, 5);
   10123 
   10124         }
   10125         finally {
   10126             dbg.exitRule(getGrammarFileName(), "relationalOp");
   10127             decRuleLevel();
   10128             if ( getRuleLevel()==0 ) {dbg.terminate();}
   10129         }
   10130 
   10131         return ;
   10132     }
   10133     // $ANTLR end "relationalOp"
   10134 
   10135 
   10136     // $ANTLR start "shiftExpression"
   10137     // src/com/google/doclava/parser/Java.g:1032:1: shiftExpression : additiveExpression ( shiftOp additiveExpression )* ;
   10138     public final void shiftExpression() throws RecognitionException {
   10139         int shiftExpression_StartIndex = input.index();
   10140         try { dbg.enterRule(getGrammarFileName(), "shiftExpression");
   10141         if ( getRuleLevel()==0 ) {dbg.commence();}
   10142         incRuleLevel();
   10143         dbg.location(1032, 1);
   10144 
   10145         try {
   10146             if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return ; }
   10147             // src/com/google/doclava/parser/Java.g:1033:5: ( additiveExpression ( shiftOp additiveExpression )* )
   10148             dbg.enterAlt(1);
   10149 
   10150             // src/com/google/doclava/parser/Java.g:1033:9: additiveExpression ( shiftOp additiveExpression )*
   10151             {
   10152             dbg.location(1033,9);
   10153             pushFollow(FOLLOW_additiveExpression_in_shiftExpression5756);
   10154             additiveExpression();
   10155 
   10156             state._fsp--;
   10157             if (state.failed) return ;
   10158             dbg.location(1034,9);
   10159             // src/com/google/doclava/parser/Java.g:1034:9: ( shiftOp additiveExpression )*
   10160             try { dbg.enterSubRule(123);
   10161 
   10162             loop123:
   10163             do {
   10164                 int alt123=2;
   10165                 try { dbg.enterDecision(123, decisionCanBacktrack[123]);
   10166 
   10167                 int LA123_0 = input.LA(1);
   10168 
   10169                 if ( (LA123_0==LT) ) {
   10170                     int LA123_1 = input.LA(2);
   10171 
   10172                     if ( (LA123_1==LT) ) {
   10173                         int LA123_4 = input.LA(3);
   10174 
   10175                         if ( ((LA123_4>=IDENTIFIER && LA123_4<=NULL)||LA123_4==BOOLEAN||LA123_4==BYTE||LA123_4==CHAR||LA123_4==DOUBLE||LA123_4==FLOAT||LA123_4==INT||LA123_4==LONG||LA123_4==NEW||LA123_4==SHORT||LA123_4==SUPER||LA123_4==THIS||LA123_4==VOID||LA123_4==LPAREN||(LA123_4>=BANG && LA123_4<=TILDE)||(LA123_4>=PLUSPLUS && LA123_4<=SUB)) ) {
   10176                             alt123=1;
   10177                         }
   10178 
   10179 
   10180                     }
   10181 
   10182 
   10183                 }
   10184                 else if ( (LA123_0==GT) ) {
   10185                     int LA123_2 = input.LA(2);
   10186 
   10187                     if ( (LA123_2==GT) ) {
   10188                         int LA123_5 = input.LA(3);
   10189 
   10190                         if ( (LA123_5==GT) ) {
   10191                             int LA123_7 = input.LA(4);
   10192 
   10193                             if ( ((LA123_7>=IDENTIFIER && LA123_7<=NULL)||LA123_7==BOOLEAN||LA123_7==BYTE||LA123_7==CHAR||LA123_7==DOUBLE||LA123_7==FLOAT||LA123_7==INT||LA123_7==LONG||LA123_7==NEW||LA123_7==SHORT||LA123_7==SUPER||LA123_7==THIS||LA123_7==VOID||LA123_7==LPAREN||(LA123_7>=BANG && LA123_7<=TILDE)||(LA123_7>=PLUSPLUS && LA123_7<=SUB)) ) {
   10194                                 alt123=1;
   10195                             }
   10196 
   10197 
   10198                         }
   10199                         else if ( ((LA123_5>=IDENTIFIER && LA123_5<=NULL)||LA123_5==BOOLEAN||LA123_5==BYTE||LA123_5==CHAR||LA123_5==DOUBLE||LA123_5==FLOAT||LA123_5==INT||LA123_5==LONG||LA123_5==NEW||LA123_5==SHORT||LA123_5==SUPER||LA123_5==THIS||LA123_5==VOID||LA123_5==LPAREN||(LA123_5>=BANG && LA123_5<=TILDE)||(LA123_5>=PLUSPLUS && LA123_5<=SUB)) ) {
   10200                             alt123=1;
   10201                         }
   10202 
   10203 
   10204                     }
   10205 
   10206 
   10207                 }
   10208 
   10209 
   10210                 } finally {dbg.exitDecision(123);}
   10211 
   10212                 switch (alt123) {
   10213 		case 1 :
   10214 		    dbg.enterAlt(1);
   10215 
   10216 		    // src/com/google/doclava/parser/Java.g:1034:10: shiftOp additiveExpression
   10217 		    {
   10218 		    dbg.location(1034,10);
   10219 		    pushFollow(FOLLOW_shiftOp_in_shiftExpression5767);
   10220 		    shiftOp();
   10221 
   10222 		    state._fsp--;
   10223 		    if (state.failed) return ;
   10224 		    dbg.location(1034,18);
   10225 		    pushFollow(FOLLOW_additiveExpression_in_shiftExpression5769);
   10226 		    additiveExpression();
   10227 
   10228 		    state._fsp--;
   10229 		    if (state.failed) return ;
   10230 
   10231 		    }
   10232 		    break;
   10233 
   10234 		default :
   10235 		    break loop123;
   10236                 }
   10237             } while (true);
   10238             } finally {dbg.exitSubRule(123);}
   10239 
   10240 
   10241             }
   10242 
   10243         }
   10244         catch (RecognitionException re) {
   10245             reportError(re);
   10246             recover(input,re);
   10247         }
   10248         finally {
   10249             if ( state.backtracking>0 ) { memoize(input, 82, shiftExpression_StartIndex); }
   10250         }
   10251         dbg.location(1036, 5);
   10252 
   10253         }
   10254         finally {
   10255             dbg.exitRule(getGrammarFileName(), "shiftExpression");
   10256             decRuleLevel();
   10257             if ( getRuleLevel()==0 ) {dbg.terminate();}
   10258         }
   10259 
   10260         return ;
   10261     }
   10262     // $ANTLR end "shiftExpression"
   10263 
   10264 
   10265     // $ANTLR start "shiftOp"
   10266     // src/com/google/doclava/parser/Java.g:1039:1: shiftOp : ( '<' '<' | '>' '>' '>' | '>' '>' );
   10267     public final void shiftOp() throws RecognitionException {
   10268         int shiftOp_StartIndex = input.index();
   10269         try { dbg.enterRule(getGrammarFileName(), "shiftOp");
   10270         if ( getRuleLevel()==0 ) {dbg.commence();}
   10271         incRuleLevel();
   10272         dbg.location(1039, 1);
   10273 
   10274         try {
   10275             if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return ; }
   10276             // src/com/google/doclava/parser/Java.g:1040:5: ( '<' '<' | '>' '>' '>' | '>' '>' )
   10277             int alt124=3;
   10278             try { dbg.enterDecision(124, decisionCanBacktrack[124]);
   10279 
   10280             int LA124_0 = input.LA(1);
   10281 
   10282             if ( (LA124_0==LT) ) {
   10283                 alt124=1;
   10284             }
   10285             else if ( (LA124_0==GT) ) {
   10286                 int LA124_2 = input.LA(2);
   10287 
   10288                 if ( (LA124_2==GT) ) {
   10289                     int LA124_3 = input.LA(3);
   10290 
   10291                     if ( (LA124_3==GT) ) {
   10292                         alt124=2;
   10293                     }
   10294                     else if ( ((LA124_3>=IDENTIFIER && LA124_3<=NULL)||LA124_3==BOOLEAN||LA124_3==BYTE||LA124_3==CHAR||LA124_3==DOUBLE||LA124_3==FLOAT||LA124_3==INT||LA124_3==LONG||LA124_3==NEW||LA124_3==SHORT||LA124_3==SUPER||LA124_3==THIS||LA124_3==VOID||LA124_3==LPAREN||(LA124_3>=BANG && LA124_3<=TILDE)||(LA124_3>=PLUSPLUS && LA124_3<=SUB)) ) {
   10295                         alt124=3;
   10296                     }
   10297                     else {
   10298                         if (state.backtracking>0) {state.failed=true; return ;}
   10299                         NoViableAltException nvae =
   10300                             new NoViableAltException("", 124, 3, input);
   10301 
   10302                         dbg.recognitionException(nvae);
   10303                         throw nvae;
   10304                     }
   10305                 }
   10306                 else {
   10307                     if (state.backtracking>0) {state.failed=true; return ;}
   10308                     NoViableAltException nvae =
   10309                         new NoViableAltException("", 124, 2, input);
   10310 
   10311                     dbg.recognitionException(nvae);
   10312                     throw nvae;
   10313                 }
   10314             }
   10315             else {
   10316                 if (state.backtracking>0) {state.failed=true; return ;}
   10317                 NoViableAltException nvae =
   10318                     new NoViableAltException("", 124, 0, input);
   10319 
   10320                 dbg.recognitionException(nvae);
   10321                 throw nvae;
   10322             }
   10323             } finally {dbg.exitDecision(124);}
   10324 
   10325             switch (alt124) {
   10326                 case 1 :
   10327                     dbg.enterAlt(1);
   10328 
   10329                     // src/com/google/doclava/parser/Java.g:1040:10: '<' '<'
   10330                     {
   10331                     dbg.location(1040,10);
   10332                     match(input,LT,FOLLOW_LT_in_shiftOp5801); if (state.failed) return ;
   10333                     dbg.location(1040,14);
   10334                     match(input,LT,FOLLOW_LT_in_shiftOp5803); if (state.failed) return ;
   10335 
   10336                     }
   10337                     break;
   10338                 case 2 :
   10339                     dbg.enterAlt(2);
   10340 
   10341                     // src/com/google/doclava/parser/Java.g:1041:10: '>' '>' '>'
   10342                     {
   10343                     dbg.location(1041,10);
   10344                     match(input,GT,FOLLOW_GT_in_shiftOp5814); if (state.failed) return ;
   10345                     dbg.location(1041,14);
   10346                     match(input,GT,FOLLOW_GT_in_shiftOp5816); if (state.failed) return ;
   10347                     dbg.location(1041,18);
   10348                     match(input,GT,FOLLOW_GT_in_shiftOp5818); if (state.failed) return ;
   10349 
   10350                     }
   10351                     break;
   10352                 case 3 :
   10353                     dbg.enterAlt(3);
   10354 
   10355                     // src/com/google/doclava/parser/Java.g:1042:10: '>' '>'
   10356                     {
   10357                     dbg.location(1042,10);
   10358                     match(input,GT,FOLLOW_GT_in_shiftOp5829); if (state.failed) return ;
   10359                     dbg.location(1042,14);
   10360                     match(input,GT,FOLLOW_GT_in_shiftOp5831); if (state.failed) return ;
   10361 
   10362                     }
   10363                     break;
   10364 
   10365             }
   10366         }
   10367         catch (RecognitionException re) {
   10368             reportError(re);
   10369             recover(input,re);
   10370         }
   10371         finally {
   10372             if ( state.backtracking>0 ) { memoize(input, 83, shiftOp_StartIndex); }
   10373         }
   10374         dbg.location(1043, 5);
   10375 
   10376         }
   10377         finally {
   10378             dbg.exitRule(getGrammarFileName(), "shiftOp");
   10379             decRuleLevel();
   10380             if ( getRuleLevel()==0 ) {dbg.terminate();}
   10381         }
   10382 
   10383         return ;
   10384     }
   10385     // $ANTLR end "shiftOp"
   10386 
   10387 
   10388     // $ANTLR start "additiveExpression"
   10389     // src/com/google/doclava/parser/Java.g:1046:1: additiveExpression : multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* ;
   10390     public final void additiveExpression() throws RecognitionException {
   10391         int additiveExpression_StartIndex = input.index();
   10392         try { dbg.enterRule(getGrammarFileName(), "additiveExpression");
   10393         if ( getRuleLevel()==0 ) {dbg.commence();}
   10394         incRuleLevel();
   10395         dbg.location(1046, 1);
   10396 
   10397         try {
   10398             if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return ; }
   10399             // src/com/google/doclava/parser/Java.g:1047:5: ( multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* )
   10400             dbg.enterAlt(1);
   10401 
   10402             // src/com/google/doclava/parser/Java.g:1047:9: multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )*
   10403             {
   10404             dbg.location(1047,9);
   10405             pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression5851);
   10406             multiplicativeExpression();
   10407 
   10408             state._fsp--;
   10409             if (state.failed) return ;
   10410             dbg.location(1048,9);
   10411             // src/com/google/doclava/parser/Java.g:1048:9: ( ( '+' | '-' ) multiplicativeExpression )*
   10412             try { dbg.enterSubRule(125);
   10413 
   10414             loop125:
   10415             do {
   10416                 int alt125=2;
   10417                 try { dbg.enterDecision(125, decisionCanBacktrack[125]);
   10418 
   10419                 int LA125_0 = input.LA(1);
   10420 
   10421                 if ( ((LA125_0>=PLUS && LA125_0<=SUB)) ) {
   10422                     alt125=1;
   10423                 }
   10424 
   10425 
   10426                 } finally {dbg.exitDecision(125);}
   10427 
   10428                 switch (alt125) {
   10429 		case 1 :
   10430 		    dbg.enterAlt(1);
   10431 
   10432 		    // src/com/google/doclava/parser/Java.g:1049:13: ( '+' | '-' ) multiplicativeExpression
   10433 		    {
   10434 		    dbg.location(1049,13);
   10435 		    if ( (input.LA(1)>=PLUS && input.LA(1)<=SUB) ) {
   10436 		        input.consume();
   10437 		        state.errorRecovery=false;state.failed=false;
   10438 		    }
   10439 		    else {
   10440 		        if (state.backtracking>0) {state.failed=true; return ;}
   10441 		        MismatchedSetException mse = new MismatchedSetException(null,input);
   10442 		        dbg.recognitionException(mse);
   10443 		        throw mse;
   10444 		    }
   10445 
   10446 		    dbg.location(1052,13);
   10447 		    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression5925);
   10448 		    multiplicativeExpression();
   10449 
   10450 		    state._fsp--;
   10451 		    if (state.failed) return ;
   10452 
   10453 		    }
   10454 		    break;
   10455 
   10456 		default :
   10457 		    break loop125;
   10458                 }
   10459             } while (true);
   10460             } finally {dbg.exitSubRule(125);}
   10461 
   10462 
   10463             }
   10464 
   10465         }
   10466         catch (RecognitionException re) {
   10467             reportError(re);
   10468             recover(input,re);
   10469         }
   10470         finally {
   10471             if ( state.backtracking>0 ) { memoize(input, 84, additiveExpression_StartIndex); }
   10472         }
   10473         dbg.location(1054, 5);
   10474 
   10475         }
   10476         finally {
   10477             dbg.exitRule(getGrammarFileName(), "additiveExpression");
   10478             decRuleLevel();
   10479             if ( getRuleLevel()==0 ) {dbg.terminate();}
   10480         }
   10481 
   10482         return ;
   10483     }
   10484     // $ANTLR end "additiveExpression"
   10485 
   10486 
   10487     // $ANTLR start "multiplicativeExpression"
   10488     // src/com/google/doclava/parser/Java.g:1056:1: multiplicativeExpression : unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* ;
   10489     public final void multiplicativeExpression() throws RecognitionException {
   10490         int multiplicativeExpression_StartIndex = input.index();
   10491         try { dbg.enterRule(getGrammarFileName(), "multiplicativeExpression");
   10492         if ( getRuleLevel()==0 ) {dbg.commence();}
   10493         incRuleLevel();
   10494         dbg.location(1056, 1);
   10495 
   10496         try {
   10497             if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return ; }
   10498             // src/com/google/doclava/parser/Java.g:1057:5: ( unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* )
   10499             dbg.enterAlt(1);
   10500 
   10501             // src/com/google/doclava/parser/Java.g:1058:9: unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )*
   10502             {
   10503             dbg.location(1058,9);
   10504             pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression5962);
   10505             unaryExpression();
   10506 
   10507             state._fsp--;
   10508             if (state.failed) return ;
   10509             dbg.location(1059,9);
   10510             // src/com/google/doclava/parser/Java.g:1059:9: ( ( '*' | '/' | '%' ) unaryExpression )*
   10511             try { dbg.enterSubRule(126);
   10512 
   10513             loop126:
   10514             do {
   10515                 int alt126=2;
   10516                 try { dbg.enterDecision(126, decisionCanBacktrack[126]);
   10517 
   10518                 int LA126_0 = input.LA(1);
   10519 
   10520                 if ( ((LA126_0>=STAR && LA126_0<=SLASH)||LA126_0==PERCENT) ) {
   10521                     alt126=1;
   10522                 }
   10523 
   10524 
   10525                 } finally {dbg.exitDecision(126);}
   10526 
   10527                 switch (alt126) {
   10528 		case 1 :
   10529 		    dbg.enterAlt(1);
   10530 
   10531 		    // src/com/google/doclava/parser/Java.g:1060:13: ( '*' | '/' | '%' ) unaryExpression
   10532 		    {
   10533 		    dbg.location(1060,13);
   10534 		    if ( (input.LA(1)>=STAR && input.LA(1)<=SLASH)||input.LA(1)==PERCENT ) {
   10535 		        input.consume();
   10536 		        state.errorRecovery=false;state.failed=false;
   10537 		    }
   10538 		    else {
   10539 		        if (state.backtracking>0) {state.failed=true; return ;}
   10540 		        MismatchedSetException mse = new MismatchedSetException(null,input);
   10541 		        dbg.recognitionException(mse);
   10542 		        throw mse;
   10543 		    }
   10544 
   10545 		    dbg.location(1064,13);
   10546 		    pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression6054);
   10547 		    unaryExpression();
   10548 
   10549 		    state._fsp--;
   10550 		    if (state.failed) return ;
   10551 
   10552 		    }
   10553 		    break;
   10554 
   10555 		default :
   10556 		    break loop126;
   10557                 }
   10558             } while (true);
   10559             } finally {dbg.exitSubRule(126);}
   10560 
   10561 
   10562             }
   10563 
   10564         }
   10565         catch (RecognitionException re) {
   10566             reportError(re);
   10567             recover(input,re);
   10568         }
   10569         finally {
   10570             if ( state.backtracking>0 ) { memoize(input, 85, multiplicativeExpression_StartIndex); }
   10571         }
   10572         dbg.location(1066, 5);
   10573 
   10574         }
   10575         finally {
   10576             dbg.exitRule(getGrammarFileName(), "multiplicativeExpression");
   10577             decRuleLevel();
   10578             if ( getRuleLevel()==0 ) {dbg.terminate();}
   10579         }
   10580 
   10581         return ;
   10582     }
   10583     // $ANTLR end "multiplicativeExpression"
   10584 
   10585 
   10586     // $ANTLR start "unaryExpression"
   10587     // src/com/google/doclava/parser/Java.g:1068:1: unaryExpression : ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus );
   10588     public final void unaryExpression() throws RecognitionException {
   10589         int unaryExpression_StartIndex = input.index();
   10590         try { dbg.enterRule(getGrammarFileName(), "unaryExpression");
   10591         if ( getRuleLevel()==0 ) {dbg.commence();}
   10592         incRuleLevel();
   10593         dbg.location(1068, 1);
   10594 
   10595         try {
   10596             if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return ; }
   10597             // src/com/google/doclava/parser/Java.g:1073:5: ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus )
   10598             int alt127=5;
   10599             try { dbg.enterDecision(127, decisionCanBacktrack[127]);
   10600 
   10601             switch ( input.LA(1) ) {
   10602             case PLUS:
   10603                 {
   10604                 alt127=1;
   10605                 }
   10606                 break;
   10607             case SUB:
   10608                 {
   10609                 alt127=2;
   10610                 }
   10611                 break;
   10612             case PLUSPLUS:
   10613                 {
   10614                 alt127=3;
   10615                 }
   10616                 break;
   10617             case SUBSUB:
   10618                 {
   10619                 alt127=4;
   10620                 }
   10621                 break;
   10622             case IDENTIFIER:
   10623             case INTLITERAL:
   10624             case LONGLITERAL:
   10625             case FLOATLITERAL:
   10626             case DOUBLELITERAL:
   10627             case CHARLITERAL:
   10628             case STRINGLITERAL:
   10629             case TRUE:
   10630             case FALSE:
   10631             case NULL:
   10632             case BOOLEAN:
   10633             case BYTE:
   10634             case CHAR:
   10635             case DOUBLE:
   10636             case FLOAT:
   10637             case INT:
   10638             case LONG:
   10639             case NEW:
   10640             case SHORT:
   10641             case SUPER:
   10642             case THIS:
   10643             case VOID:
   10644             case LPAREN:
   10645             case BANG:
   10646             case TILDE:
   10647                 {
   10648                 alt127=5;
   10649                 }
   10650                 break;
   10651             default:
   10652                 if (state.backtracking>0) {state.failed=true; return ;}
   10653                 NoViableAltException nvae =
   10654                     new NoViableAltException("", 127, 0, input);
   10655 
   10656                 dbg.recognitionException(nvae);
   10657                 throw nvae;
   10658             }
   10659 
   10660             } finally {dbg.exitDecision(127);}
   10661 
   10662             switch (alt127) {
   10663                 case 1 :
   10664                     dbg.enterAlt(1);
   10665 
   10666                     // src/com/google/doclava/parser/Java.g:1073:9: '+' unaryExpression
   10667                     {
   10668                     dbg.location(1073,9);
   10669                     match(input,PLUS,FOLLOW_PLUS_in_unaryExpression6086); if (state.failed) return ;
   10670                     dbg.location(1073,14);
   10671                     pushFollow(FOLLOW_unaryExpression_in_unaryExpression6089);
   10672                     unaryExpression();
   10673 
   10674                     state._fsp--;
   10675                     if (state.failed) return ;
   10676 
   10677                     }
   10678                     break;
   10679                 case 2 :
   10680                     dbg.enterAlt(2);
   10681 
   10682                     // src/com/google/doclava/parser/Java.g:1074:9: '-' unaryExpression
   10683                     {
   10684                     dbg.location(1074,9);
   10685                     match(input,SUB,FOLLOW_SUB_in_unaryExpression6099); if (state.failed) return ;
   10686                     dbg.location(1074,13);
   10687                     pushFollow(FOLLOW_unaryExpression_in_unaryExpression6101);
   10688                     unaryExpression();
   10689 
   10690                     state._fsp--;
   10691                     if (state.failed) return ;
   10692 
   10693                     }
   10694                     break;
   10695                 case 3 :
   10696                     dbg.enterAlt(3);
   10697 
   10698                     // src/com/google/doclava/parser/Java.g:1075:9: '++' unaryExpression
   10699                     {
   10700                     dbg.location(1075,9);
   10701                     match(input,PLUSPLUS,FOLLOW_PLUSPLUS_in_unaryExpression6111); if (state.failed) return ;
   10702                     dbg.location(1075,14);
   10703                     pushFollow(FOLLOW_unaryExpression_in_unaryExpression6113);
   10704                     unaryExpression();
   10705 
   10706                     state._fsp--;
   10707                     if (state.failed) return ;
   10708 
   10709                     }
   10710                     break;
   10711                 case 4 :
   10712                     dbg.enterAlt(4);
   10713 
   10714                     // src/com/google/doclava/parser/Java.g:1076:9: '--' unaryExpression
   10715                     {
   10716                     dbg.location(1076,9);
   10717                     match(input,SUBSUB,FOLLOW_SUBSUB_in_unaryExpression6123); if (state.failed) return ;
   10718                     dbg.location(1076,14);
   10719                     pushFollow(FOLLOW_unaryExpression_in_unaryExpression6125);
   10720                     unaryExpression();
   10721 
   10722                     state._fsp--;
   10723                     if (state.failed) return ;
   10724 
   10725                     }
   10726                     break;
   10727                 case 5 :
   10728                     dbg.enterAlt(5);
   10729 
   10730                     // src/com/google/doclava/parser/Java.g:1077:9: unaryExpressionNotPlusMinus
   10731                     {
   10732                     dbg.location(1077,9);
   10733                     pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression6135);
   10734                     unaryExpressionNotPlusMinus();
   10735 
   10736                     state._fsp--;
   10737                     if (state.failed) return ;
   10738 
   10739                     }
   10740                     break;
   10741 
   10742             }
   10743         }
   10744         catch (RecognitionException re) {
   10745             reportError(re);
   10746             recover(input,re);
   10747         }
   10748         finally {
   10749             if ( state.backtracking>0 ) { memoize(input, 86, unaryExpression_StartIndex); }
   10750         }
   10751         dbg.location(1078, 5);
   10752 
   10753         }
   10754         finally {
   10755             dbg.exitRule(getGrammarFileName(), "unaryExpression");
   10756             decRuleLevel();
   10757             if ( getRuleLevel()==0 ) {dbg.terminate();}
   10758         }
   10759 
   10760         return ;
   10761     }
   10762     // $ANTLR end "unaryExpression"
   10763 
   10764 
   10765     // $ANTLR start "unaryExpressionNotPlusMinus"
   10766     // src/com/google/doclava/parser/Java.g:1080:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? );
   10767     public final void unaryExpressionNotPlusMinus() throws RecognitionException {
   10768         int unaryExpressionNotPlusMinus_StartIndex = input.index();
   10769         try { dbg.enterRule(getGrammarFileName(), "unaryExpressionNotPlusMinus");
   10770         if ( getRuleLevel()==0 ) {dbg.commence();}
   10771         incRuleLevel();
   10772         dbg.location(1080, 1);
   10773 
   10774         try {
   10775             if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return ; }
   10776             // src/com/google/doclava/parser/Java.g:1081:5: ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? )
   10777             int alt130=4;
   10778             try { dbg.enterDecision(130, decisionCanBacktrack[130]);
   10779 
   10780             try {
   10781                 isCyclicDecision = true;
   10782                 alt130 = dfa130.predict(input);
   10783             }
   10784             catch (NoViableAltException nvae) {
   10785                 dbg.recognitionException(nvae);
   10786                 throw nvae;
   10787             }
   10788             } finally {dbg.exitDecision(130);}
   10789 
   10790             switch (alt130) {
   10791                 case 1 :
   10792                     dbg.enterAlt(1);
   10793 
   10794                     // src/com/google/doclava/parser/Java.g:1081:9: '~' unaryExpression
   10795                     {
   10796                     dbg.location(1081,9);
   10797                     match(input,TILDE,FOLLOW_TILDE_in_unaryExpressionNotPlusMinus6154); if (state.failed) return ;
   10798                     dbg.location(1081,13);
   10799                     pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6156);
   10800                     unaryExpression();
   10801 
   10802                     state._fsp--;
   10803                     if (state.failed) return ;
   10804 
   10805                     }
   10806                     break;
   10807                 case 2 :
   10808                     dbg.enterAlt(2);
   10809 
   10810                     // src/com/google/doclava/parser/Java.g:1082:9: '!' unaryExpression
   10811                     {
   10812                     dbg.location(1082,9);
   10813                     match(input,BANG,FOLLOW_BANG_in_unaryExpressionNotPlusMinus6166); if (state.failed) return ;
   10814                     dbg.location(1082,13);
   10815                     pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6168);
   10816                     unaryExpression();
   10817 
   10818                     state._fsp--;
   10819                     if (state.failed) return ;
   10820 
   10821                     }
   10822                     break;
   10823                 case 3 :
   10824                     dbg.enterAlt(3);
   10825 
   10826                     // src/com/google/doclava/parser/Java.g:1083:9: castExpression
   10827                     {
   10828                     dbg.location(1083,9);
   10829                     pushFollow(FOLLOW_castExpression_in_unaryExpressionNotPlusMinus6178);
   10830                     castExpression();
   10831 
   10832                     state._fsp--;
   10833                     if (state.failed) return ;
   10834 
   10835                     }
   10836                     break;
   10837                 case 4 :
   10838                     dbg.enterAlt(4);
   10839 
   10840                     // src/com/google/doclava/parser/Java.g:1084:9: primary ( selector )* ( '++' | '--' )?
   10841                     {
   10842                     dbg.location(1084,9);
   10843                     pushFollow(FOLLOW_primary_in_unaryExpressionNotPlusMinus6188);
   10844                     primary();
   10845 
   10846                     state._fsp--;
   10847                     if (state.failed) return ;
   10848                     dbg.location(1085,9);
   10849                     // src/com/google/doclava/parser/Java.g:1085:9: ( selector )*
   10850                     try { dbg.enterSubRule(128);
   10851 
   10852                     loop128:
   10853                     do {
   10854                         int alt128=2;
   10855                         try { dbg.enterDecision(128, decisionCanBacktrack[128]);
   10856 
   10857                         int LA128_0 = input.LA(1);
   10858 
   10859                         if ( (LA128_0==LBRACKET||LA128_0==DOT) ) {
   10860                             alt128=1;
   10861                         }
   10862 
   10863 
   10864                         } finally {dbg.exitDecision(128);}
   10865 
   10866                         switch (alt128) {
   10867 			case 1 :
   10868 			    dbg.enterAlt(1);
   10869 
   10870 			    // src/com/google/doclava/parser/Java.g:1085:10: selector
   10871 			    {
   10872 			    dbg.location(1085,10);
   10873 			    pushFollow(FOLLOW_selector_in_unaryExpressionNotPlusMinus6199);
   10874 			    selector();
   10875 
   10876 			    state._fsp--;
   10877 			    if (state.failed) return ;
   10878 
   10879 			    }
   10880 			    break;
   10881 
   10882 			default :
   10883 			    break loop128;
   10884                         }
   10885                     } while (true);
   10886                     } finally {dbg.exitSubRule(128);}
   10887 
   10888                     dbg.location(1087,9);
   10889                     // src/com/google/doclava/parser/Java.g:1087:9: ( '++' | '--' )?
   10890                     int alt129=2;
   10891                     try { dbg.enterSubRule(129);
   10892                     try { dbg.enterDecision(129, decisionCanBacktrack[129]);
   10893 
   10894                     int LA129_0 = input.LA(1);
   10895 
   10896                     if ( ((LA129_0>=PLUSPLUS && LA129_0<=SUBSUB)) ) {
   10897                         alt129=1;
   10898                     }
   10899                     } finally {dbg.exitDecision(129);}
   10900 
   10901                     switch (alt129) {
   10902                         case 1 :
   10903                             dbg.enterAlt(1);
   10904 
   10905                             // src/com/google/doclava/parser/Java.g:
   10906                             {
   10907                             dbg.location(1087,9);
   10908                             if ( (input.LA(1)>=PLUSPLUS && input.LA(1)<=SUBSUB) ) {
   10909                                 input.consume();
   10910                                 state.errorRecovery=false;state.failed=false;
   10911                             }
   10912                             else {
   10913                                 if (state.backtracking>0) {state.failed=true; return ;}
   10914                                 MismatchedSetException mse = new MismatchedSetException(null,input);
   10915                                 dbg.recognitionException(mse);
   10916                                 throw mse;
   10917                             }
   10918 
   10919 
   10920                             }
   10921                             break;
   10922 
   10923                     }
   10924                     } finally {dbg.exitSubRule(129);}
   10925 
   10926 
   10927                     }
   10928                     break;
   10929 
   10930             }
   10931         }
   10932         catch (RecognitionException re) {
   10933             reportError(re);
   10934             recover(input,re);
   10935         }
   10936         finally {
   10937             if ( state.backtracking>0 ) { memoize(input, 87, unaryExpressionNotPlusMinus_StartIndex); }
   10938         }
   10939         dbg.location(1090, 5);
   10940 
   10941         }
   10942         finally {
   10943             dbg.exitRule(getGrammarFileName(), "unaryExpressionNotPlusMinus");
   10944             decRuleLevel();
   10945             if ( getRuleLevel()==0 ) {dbg.terminate();}
   10946         }
   10947 
   10948         return ;
   10949     }
   10950     // $ANTLR end "unaryExpressionNotPlusMinus"
   10951 
   10952 
   10953     // $ANTLR start "castExpression"
   10954     // src/com/google/doclava/parser/Java.g:1092:1: castExpression : ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus );
   10955     public final void castExpression() throws RecognitionException {
   10956         int castExpression_StartIndex = input.index();
   10957         try { dbg.enterRule(getGrammarFileName(), "castExpression");
   10958         if ( getRuleLevel()==0 ) {dbg.commence();}
   10959         incRuleLevel();
   10960         dbg.location(1092, 1);
   10961 
   10962         try {
   10963             if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return ; }
   10964             // src/com/google/doclava/parser/Java.g:1093:5: ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus )
   10965             int alt131=2;
   10966             try { dbg.enterDecision(131, decisionCanBacktrack[131]);
   10967 
   10968             int LA131_0 = input.LA(1);
   10969 
   10970             if ( (LA131_0==LPAREN) ) {
   10971                 int LA131_1 = input.LA(2);
   10972 
   10973                 if ( (synpred206_Java()) ) {
   10974                     alt131=1;
   10975                 }
   10976                 else if ( (true) ) {
   10977                     alt131=2;
   10978                 }
   10979                 else {
   10980                     if (state.backtracking>0) {state.failed=true; return ;}
   10981                     NoViableAltException nvae =
   10982                         new NoViableAltException("", 131, 1, input);
   10983 
   10984                     dbg.recognitionException(nvae);
   10985                     throw nvae;
   10986                 }
   10987             }
   10988             else {
   10989                 if (state.backtracking>0) {state.failed=true; return ;}
   10990                 NoViableAltException nvae =
   10991                     new NoViableAltException("", 131, 0, input);
   10992 
   10993                 dbg.recognitionException(nvae);
   10994                 throw nvae;
   10995             }
   10996             } finally {dbg.exitDecision(131);}
   10997 
   10998             switch (alt131) {
   10999                 case 1 :
   11000                     dbg.enterAlt(1);
   11001 
   11002                     // src/com/google/doclava/parser/Java.g:1093:9: '(' primitiveType ')' unaryExpression
   11003                     {
   11004                     dbg.location(1093,9);
   11005                     match(input,LPAREN,FOLLOW_LPAREN_in_castExpression6268); if (state.failed) return ;
   11006                     dbg.location(1093,13);
   11007                     pushFollow(FOLLOW_primitiveType_in_castExpression6270);
   11008                     primitiveType();
   11009 
   11010                     state._fsp--;
   11011                     if (state.failed) return ;
   11012                     dbg.location(1093,27);
   11013                     match(input,RPAREN,FOLLOW_RPAREN_in_castExpression6272); if (state.failed) return ;
   11014                     dbg.location(1093,31);
   11015                     pushFollow(FOLLOW_unaryExpression_in_castExpression6274);
   11016                     unaryExpression();
   11017 
   11018                     state._fsp--;
   11019                     if (state.failed) return ;
   11020 
   11021                     }
   11022                     break;
   11023                 case 2 :
   11024                     dbg.enterAlt(2);
   11025 
   11026                     // src/com/google/doclava/parser/Java.g:1094:9: '(' type ')' unaryExpressionNotPlusMinus
   11027                     {
   11028                     dbg.location(1094,9);
   11029                     match(input,LPAREN,FOLLOW_LPAREN_in_castExpression6284); if (state.failed) return ;
   11030                     dbg.location(1094,13);
   11031                     pushFollow(FOLLOW_type_in_castExpression6286);
   11032                     type();
   11033 
   11034                     state._fsp--;
   11035                     if (state.failed) return ;
   11036                     dbg.location(1094,18);
   11037                     match(input,RPAREN,FOLLOW_RPAREN_in_castExpression6288); if (state.failed) return ;
   11038                     dbg.location(1094,22);
   11039                     pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_castExpression6290);
   11040                     unaryExpressionNotPlusMinus();
   11041 
   11042                     state._fsp--;
   11043                     if (state.failed) return ;
   11044 
   11045                     }
   11046                     break;
   11047 
   11048             }
   11049         }
   11050         catch (RecognitionException re) {
   11051             reportError(re);
   11052             recover(input,re);
   11053         }
   11054         finally {
   11055             if ( state.backtracking>0 ) { memoize(input, 88, castExpression_StartIndex); }
   11056         }
   11057         dbg.location(1095, 5);
   11058 
   11059         }
   11060         finally {
   11061             dbg.exitRule(getGrammarFileName(), "castExpression");
   11062             decRuleLevel();
   11063             if ( getRuleLevel()==0 ) {dbg.terminate();}
   11064         }
   11065 
   11066         return ;
   11067     }
   11068     // $ANTLR end "castExpression"
   11069 
   11070 
   11071     // $ANTLR start "primary"
   11072     // src/com/google/doclava/parser/Java.g:1097:1: primary : ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' );
   11073     public final void primary() throws RecognitionException {
   11074         int primary_StartIndex = input.index();
   11075         try { dbg.enterRule(getGrammarFileName(), "primary");
   11076         if ( getRuleLevel()==0 ) {dbg.commence();}
   11077         incRuleLevel();
   11078         dbg.location(1097, 1);
   11079 
   11080         try {
   11081             if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return ; }
   11082             // src/com/google/doclava/parser/Java.g:1101:5: ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' )
   11083             int alt137=8;
   11084             try { dbg.enterDecision(137, decisionCanBacktrack[137]);
   11085 
   11086             switch ( input.LA(1) ) {
   11087             case LPAREN:
   11088                 {
   11089                 alt137=1;
   11090                 }
   11091                 break;
   11092             case THIS:
   11093                 {
   11094                 alt137=2;
   11095                 }
   11096                 break;
   11097             case IDENTIFIER:
   11098                 {
   11099                 alt137=3;
   11100                 }
   11101                 break;
   11102             case SUPER:
   11103                 {
   11104                 alt137=4;
   11105                 }
   11106                 break;
   11107             case INTLITERAL:
   11108             case LONGLITERAL:
   11109             case FLOATLITERAL:
   11110             case DOUBLELITERAL:
   11111             case CHARLITERAL:
   11112             case STRINGLITERAL:
   11113             case TRUE:
   11114             case FALSE:
   11115             case NULL:
   11116                 {
   11117                 alt137=5;
   11118                 }
   11119                 break;
   11120             case NEW:
   11121                 {
   11122                 alt137=6;
   11123                 }
   11124                 break;
   11125             case BOOLEAN:
   11126             case BYTE:
   11127             case CHAR:
   11128             case DOUBLE:
   11129             case FLOAT:
   11130             case INT:
   11131             case LONG:
   11132             case SHORT:
   11133                 {
   11134                 alt137=7;
   11135                 }
   11136                 break;
   11137             case VOID:
   11138                 {
   11139                 alt137=8;
   11140                 }
   11141                 break;
   11142             default:
   11143                 if (state.backtracking>0) {state.failed=true; return ;}
   11144                 NoViableAltException nvae =
   11145                     new NoViableAltException("", 137, 0, input);
   11146 
   11147                 dbg.recognitionException(nvae);
   11148                 throw nvae;
   11149             }
   11150 
   11151             } finally {dbg.exitDecision(137);}
   11152 
   11153             switch (alt137) {
   11154                 case 1 :
   11155                     dbg.enterAlt(1);
   11156 
   11157                     // src/com/google/doclava/parser/Java.g:1101:9: parExpression
   11158                     {
   11159                     dbg.location(1101,9);
   11160                     pushFollow(FOLLOW_parExpression_in_primary6311);
   11161                     parExpression();
   11162 
   11163                     state._fsp--;
   11164                     if (state.failed) return ;
   11165 
   11166                     }
   11167                     break;
   11168                 case 2 :
   11169                     dbg.enterAlt(2);
   11170 
   11171                     // src/com/google/doclava/parser/Java.g:1102:9: 'this' ( '.' IDENTIFIER )* ( identifierSuffix )?
   11172                     {
   11173                     dbg.location(1102,9);
   11174                     match(input,THIS,FOLLOW_THIS_in_primary6321); if (state.failed) return ;
   11175                     dbg.location(1103,9);
   11176                     // src/com/google/doclava/parser/Java.g:1103:9: ( '.' IDENTIFIER )*
   11177                     try { dbg.enterSubRule(132);
   11178 
   11179                     loop132:
   11180                     do {
   11181                         int alt132=2;
   11182                         try { dbg.enterDecision(132, decisionCanBacktrack[132]);
   11183 
   11184                         int LA132_0 = input.LA(1);
   11185 
   11186                         if ( (LA132_0==DOT) ) {
   11187                             int LA132_2 = input.LA(2);
   11188 
   11189                             if ( (LA132_2==IDENTIFIER) ) {
   11190                                 int LA132_3 = input.LA(3);
   11191 
   11192                                 if ( (synpred208_Java()) ) {
   11193                                     alt132=1;
   11194                                 }
   11195 
   11196 
   11197                             }
   11198 
   11199 
   11200                         }
   11201 
   11202 
   11203                         } finally {dbg.exitDecision(132);}
   11204 
   11205                         switch (alt132) {
   11206 			case 1 :
   11207 			    dbg.enterAlt(1);
   11208 
   11209 			    // src/com/google/doclava/parser/Java.g:1103:10: '.' IDENTIFIER
   11210 			    {
   11211 			    dbg.location(1103,10);
   11212 			    match(input,DOT,FOLLOW_DOT_in_primary6332); if (state.failed) return ;
   11213 			    dbg.location(1103,14);
   11214 			    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6334); if (state.failed) return ;
   11215 
   11216 			    }
   11217 			    break;
   11218 
   11219 			default :
   11220 			    break loop132;
   11221                         }
   11222                     } while (true);
   11223                     } finally {dbg.exitSubRule(132);}
   11224 
   11225                     dbg.location(1105,9);
   11226                     // src/com/google/doclava/parser/Java.g:1105:9: ( identifierSuffix )?
   11227                     int alt133=2;
   11228                     try { dbg.enterSubRule(133);
   11229                     try { dbg.enterDecision(133, decisionCanBacktrack[133]);
   11230 
   11231                     try {
   11232                         isCyclicDecision = true;
   11233                         alt133 = dfa133.predict(input);
   11234                     }
   11235                     catch (NoViableAltException nvae) {
   11236                         dbg.recognitionException(nvae);
   11237                         throw nvae;
   11238                     }
   11239                     } finally {dbg.exitDecision(133);}
   11240 
   11241                     switch (alt133) {
   11242                         case 1 :
   11243                             dbg.enterAlt(1);
   11244 
   11245                             // src/com/google/doclava/parser/Java.g:1105:10: identifierSuffix
   11246                             {
   11247                             dbg.location(1105,10);
   11248                             pushFollow(FOLLOW_identifierSuffix_in_primary6356);
   11249                             identifierSuffix();
   11250 
   11251                             state._fsp--;
   11252                             if (state.failed) return ;
   11253 
   11254                             }
   11255                             break;
   11256 
   11257                     }
   11258                     } finally {dbg.exitSubRule(133);}
   11259 
   11260 
   11261                     }
   11262                     break;
   11263                 case 3 :
   11264                     dbg.enterAlt(3);
   11265 
   11266                     // src/com/google/doclava/parser/Java.g:1107:9: IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )?
   11267                     {
   11268                     dbg.location(1107,9);
   11269                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6377); if (state.failed) return ;
   11270                     dbg.location(1108,9);
   11271                     // src/com/google/doclava/parser/Java.g:1108:9: ( '.' IDENTIFIER )*
   11272                     try { dbg.enterSubRule(134);
   11273 
   11274                     loop134:
   11275                     do {
   11276                         int alt134=2;
   11277                         try { dbg.enterDecision(134, decisionCanBacktrack[134]);
   11278 
   11279                         int LA134_0 = input.LA(1);
   11280 
   11281                         if ( (LA134_0==DOT) ) {
   11282                             int LA134_2 = input.LA(2);
   11283 
   11284                             if ( (LA134_2==IDENTIFIER) ) {
   11285                                 int LA134_3 = input.LA(3);
   11286 
   11287                                 if ( (synpred211_Java()) ) {
   11288                                     alt134=1;
   11289                                 }
   11290 
   11291 
   11292                             }
   11293 
   11294 
   11295                         }
   11296 
   11297 
   11298                         } finally {dbg.exitDecision(134);}
   11299 
   11300                         switch (alt134) {
   11301 			case 1 :
   11302 			    dbg.enterAlt(1);
   11303 
   11304 			    // src/com/google/doclava/parser/Java.g:1108:10: '.' IDENTIFIER
   11305 			    {
   11306 			    dbg.location(1108,10);
   11307 			    match(input,DOT,FOLLOW_DOT_in_primary6388); if (state.failed) return ;
   11308 			    dbg.location(1108,14);
   11309 			    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6390); if (state.failed) return ;
   11310 
   11311 			    }
   11312 			    break;
   11313 
   11314 			default :
   11315 			    break loop134;
   11316                         }
   11317                     } while (true);
   11318                     } finally {dbg.exitSubRule(134);}
   11319 
   11320                     dbg.location(1110,9);
   11321                     // src/com/google/doclava/parser/Java.g:1110:9: ( identifierSuffix )?
   11322                     int alt135=2;
   11323                     try { dbg.enterSubRule(135);
   11324                     try { dbg.enterDecision(135, decisionCanBacktrack[135]);
   11325 
   11326                     try {
   11327                         isCyclicDecision = true;
   11328                         alt135 = dfa135.predict(input);
   11329                     }
   11330                     catch (NoViableAltException nvae) {
   11331                         dbg.recognitionException(nvae);
   11332                         throw nvae;
   11333                     }
   11334                     } finally {dbg.exitDecision(135);}
   11335 
   11336                     switch (alt135) {
   11337                         case 1 :
   11338                             dbg.enterAlt(1);
   11339 
   11340                             // src/com/google/doclava/parser/Java.g:1110:10: identifierSuffix
   11341                             {
   11342                             dbg.location(1110,10);
   11343                             pushFollow(FOLLOW_identifierSuffix_in_primary6412);
   11344                             identifierSuffix();
   11345 
   11346                             state._fsp--;
   11347                             if (state.failed) return ;
   11348 
   11349                             }
   11350                             break;
   11351 
   11352                     }
   11353                     } finally {dbg.exitSubRule(135);}
   11354 
   11355 
   11356                     }
   11357                     break;
   11358                 case 4 :
   11359                     dbg.enterAlt(4);
   11360 
   11361                     // src/com/google/doclava/parser/Java.g:1112:9: 'super' superSuffix
   11362                     {
   11363                     dbg.location(1112,9);
   11364                     match(input,SUPER,FOLLOW_SUPER_in_primary6433); if (state.failed) return ;
   11365                     dbg.location(1113,9);
   11366                     pushFollow(FOLLOW_superSuffix_in_primary6443);
   11367                     superSuffix();
   11368 
   11369                     state._fsp--;
   11370                     if (state.failed) return ;
   11371 
   11372                     }
   11373                     break;
   11374                 case 5 :
   11375                     dbg.enterAlt(5);
   11376 
   11377                     // src/com/google/doclava/parser/Java.g:1114:9: literal
   11378                     {
   11379                     dbg.location(1114,9);
   11380                     pushFollow(FOLLOW_literal_in_primary6453);
   11381                     literal();
   11382 
   11383                     state._fsp--;
   11384                     if (state.failed) return ;
   11385 
   11386                     }
   11387                     break;
   11388                 case 6 :
   11389                     dbg.enterAlt(6);
   11390 
   11391                     // src/com/google/doclava/parser/Java.g:1115:9: creator
   11392                     {
   11393                     dbg.location(1115,9);
   11394                     pushFollow(FOLLOW_creator_in_primary6463);
   11395                     creator();
   11396 
   11397                     state._fsp--;
   11398                     if (state.failed) return ;
   11399 
   11400                     }
   11401                     break;
   11402                 case 7 :
   11403                     dbg.enterAlt(7);
   11404 
   11405                     // src/com/google/doclava/parser/Java.g:1116:9: primitiveType ( '[' ']' )* '.' 'class'
   11406                     {
   11407                     dbg.location(1116,9);
   11408                     pushFollow(FOLLOW_primitiveType_in_primary6473);
   11409                     primitiveType();
   11410 
   11411                     state._fsp--;
   11412                     if (state.failed) return ;
   11413                     dbg.location(1117,9);
   11414                     // src/com/google/doclava/parser/Java.g:1117:9: ( '[' ']' )*
   11415                     try { dbg.enterSubRule(136);
   11416 
   11417                     loop136:
   11418                     do {
   11419                         int alt136=2;
   11420                         try { dbg.enterDecision(136, decisionCanBacktrack[136]);
   11421 
   11422                         int LA136_0 = input.LA(1);
   11423 
   11424                         if ( (LA136_0==LBRACKET) ) {
   11425                             alt136=1;
   11426                         }
   11427 
   11428 
   11429                         } finally {dbg.exitDecision(136);}
   11430 
   11431                         switch (alt136) {
   11432 			case 1 :
   11433 			    dbg.enterAlt(1);
   11434 
   11435 			    // src/com/google/doclava/parser/Java.g:1117:10: '[' ']'
   11436 			    {
   11437 			    dbg.location(1117,10);
   11438 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_primary6484); if (state.failed) return ;
   11439 			    dbg.location(1117,14);
   11440 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_primary6486); if (state.failed) return ;
   11441 
   11442 			    }
   11443 			    break;
   11444 
   11445 			default :
   11446 			    break loop136;
   11447                         }
   11448                     } while (true);
   11449                     } finally {dbg.exitSubRule(136);}
   11450 
   11451                     dbg.location(1119,9);
   11452                     match(input,DOT,FOLLOW_DOT_in_primary6507); if (state.failed) return ;
   11453                     dbg.location(1119,13);
   11454                     match(input,CLASS,FOLLOW_CLASS_in_primary6509); if (state.failed) return ;
   11455 
   11456                     }
   11457                     break;
   11458                 case 8 :
   11459                     dbg.enterAlt(8);
   11460 
   11461                     // src/com/google/doclava/parser/Java.g:1120:9: 'void' '.' 'class'
   11462                     {
   11463                     dbg.location(1120,9);
   11464                     match(input,VOID,FOLLOW_VOID_in_primary6519); if (state.failed) return ;
   11465                     dbg.location(1120,16);
   11466                     match(input,DOT,FOLLOW_DOT_in_primary6521); if (state.failed) return ;
   11467                     dbg.location(1120,20);
   11468                     match(input,CLASS,FOLLOW_CLASS_in_primary6523); if (state.failed) return ;
   11469 
   11470                     }
   11471                     break;
   11472 
   11473             }
   11474         }
   11475         catch (RecognitionException re) {
   11476             reportError(re);
   11477             recover(input,re);
   11478         }
   11479         finally {
   11480             if ( state.backtracking>0 ) { memoize(input, 89, primary_StartIndex); }
   11481         }
   11482         dbg.location(1121, 5);
   11483 
   11484         }
   11485         finally {
   11486             dbg.exitRule(getGrammarFileName(), "primary");
   11487             decRuleLevel();
   11488             if ( getRuleLevel()==0 ) {dbg.terminate();}
   11489         }
   11490 
   11491         return ;
   11492     }
   11493     // $ANTLR end "primary"
   11494 
   11495 
   11496     // $ANTLR start "superSuffix"
   11497     // src/com/google/doclava/parser/Java.g:1124:1: superSuffix : ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? );
   11498     public final void superSuffix() throws RecognitionException {
   11499         int superSuffix_StartIndex = input.index();
   11500         try { dbg.enterRule(getGrammarFileName(), "superSuffix");
   11501         if ( getRuleLevel()==0 ) {dbg.commence();}
   11502         incRuleLevel();
   11503         dbg.location(1124, 1);
   11504 
   11505         try {
   11506             if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return ; }
   11507             // src/com/google/doclava/parser/Java.g:1125:5: ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? )
   11508             int alt140=2;
   11509             try { dbg.enterDecision(140, decisionCanBacktrack[140]);
   11510 
   11511             int LA140_0 = input.LA(1);
   11512 
   11513             if ( (LA140_0==LPAREN) ) {
   11514                 alt140=1;
   11515             }
   11516             else if ( (LA140_0==DOT) ) {
   11517                 alt140=2;
   11518             }
   11519             else {
   11520                 if (state.backtracking>0) {state.failed=true; return ;}
   11521                 NoViableAltException nvae =
   11522                     new NoViableAltException("", 140, 0, input);
   11523 
   11524                 dbg.recognitionException(nvae);
   11525                 throw nvae;
   11526             }
   11527             } finally {dbg.exitDecision(140);}
   11528 
   11529             switch (alt140) {
   11530                 case 1 :
   11531                     dbg.enterAlt(1);
   11532 
   11533                     // src/com/google/doclava/parser/Java.g:1125:9: arguments
   11534                     {
   11535                     dbg.location(1125,9);
   11536                     pushFollow(FOLLOW_arguments_in_superSuffix6543);
   11537                     arguments();
   11538 
   11539                     state._fsp--;
   11540                     if (state.failed) return ;
   11541 
   11542                     }
   11543                     break;
   11544                 case 2 :
   11545                     dbg.enterAlt(2);
   11546 
   11547                     // src/com/google/doclava/parser/Java.g:1126:9: '.' ( typeArguments )? IDENTIFIER ( arguments )?
   11548                     {
   11549                     dbg.location(1126,9);
   11550                     match(input,DOT,FOLLOW_DOT_in_superSuffix6553); if (state.failed) return ;
   11551                     dbg.location(1126,13);
   11552                     // src/com/google/doclava/parser/Java.g:1126:13: ( typeArguments )?
   11553                     int alt138=2;
   11554                     try { dbg.enterSubRule(138);
   11555                     try { dbg.enterDecision(138, decisionCanBacktrack[138]);
   11556 
   11557                     int LA138_0 = input.LA(1);
   11558 
   11559                     if ( (LA138_0==LT) ) {
   11560                         alt138=1;
   11561                     }
   11562                     } finally {dbg.exitDecision(138);}
   11563 
   11564                     switch (alt138) {
   11565                         case 1 :
   11566                             dbg.enterAlt(1);
   11567 
   11568                             // src/com/google/doclava/parser/Java.g:1126:14: typeArguments
   11569                             {
   11570                             dbg.location(1126,14);
   11571                             pushFollow(FOLLOW_typeArguments_in_superSuffix6556);
   11572                             typeArguments();
   11573 
   11574                             state._fsp--;
   11575                             if (state.failed) return ;
   11576 
   11577                             }
   11578                             break;
   11579 
   11580                     }
   11581                     } finally {dbg.exitSubRule(138);}
   11582 
   11583                     dbg.location(1128,9);
   11584                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_superSuffix6577); if (state.failed) return ;
   11585                     dbg.location(1129,9);
   11586                     // src/com/google/doclava/parser/Java.g:1129:9: ( arguments )?
   11587                     int alt139=2;
   11588                     try { dbg.enterSubRule(139);
   11589                     try { dbg.enterDecision(139, decisionCanBacktrack[139]);
   11590 
   11591                     int LA139_0 = input.LA(1);
   11592 
   11593                     if ( (LA139_0==LPAREN) ) {
   11594                         alt139=1;
   11595                     }
   11596                     } finally {dbg.exitDecision(139);}
   11597 
   11598                     switch (alt139) {
   11599                         case 1 :
   11600                             dbg.enterAlt(1);
   11601 
   11602                             // src/com/google/doclava/parser/Java.g:1129:10: arguments
   11603                             {
   11604                             dbg.location(1129,10);
   11605                             pushFollow(FOLLOW_arguments_in_superSuffix6588);
   11606                             arguments();
   11607 
   11608                             state._fsp--;
   11609                             if (state.failed) return ;
   11610 
   11611                             }
   11612                             break;
   11613 
   11614                     }
   11615                     } finally {dbg.exitSubRule(139);}
   11616 
   11617 
   11618                     }
   11619                     break;
   11620 
   11621             }
   11622         }
   11623         catch (RecognitionException re) {
   11624             reportError(re);
   11625             recover(input,re);
   11626         }
   11627         finally {
   11628             if ( state.backtracking>0 ) { memoize(input, 90, superSuffix_StartIndex); }
   11629         }
   11630         dbg.location(1131, 5);
   11631 
   11632         }
   11633         finally {
   11634             dbg.exitRule(getGrammarFileName(), "superSuffix");
   11635             decRuleLevel();
   11636             if ( getRuleLevel()==0 ) {dbg.terminate();}
   11637         }
   11638 
   11639         return ;
   11640     }
   11641     // $ANTLR end "superSuffix"
   11642 
   11643 
   11644     // $ANTLR start "identifierSuffix"
   11645     // src/com/google/doclava/parser/Java.g:1134:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator );
   11646     public final void identifierSuffix() throws RecognitionException {
   11647         int identifierSuffix_StartIndex = input.index();
   11648         try { dbg.enterRule(getGrammarFileName(), "identifierSuffix");
   11649         if ( getRuleLevel()==0 ) {dbg.commence();}
   11650         incRuleLevel();
   11651         dbg.location(1134, 1);
   11652 
   11653         try {
   11654             if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return ; }
   11655             // src/com/google/doclava/parser/Java.g:1135:5: ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator )
   11656             int alt143=8;
   11657             try { dbg.enterDecision(143, decisionCanBacktrack[143]);
   11658 
   11659             try {
   11660                 isCyclicDecision = true;
   11661                 alt143 = dfa143.predict(input);
   11662             }
   11663             catch (NoViableAltException nvae) {
   11664                 dbg.recognitionException(nvae);
   11665                 throw nvae;
   11666             }
   11667             } finally {dbg.exitDecision(143);}
   11668 
   11669             switch (alt143) {
   11670                 case 1 :
   11671                     dbg.enterAlt(1);
   11672 
   11673                     // src/com/google/doclava/parser/Java.g:1135:9: ( '[' ']' )+ '.' 'class'
   11674                     {
   11675                     dbg.location(1135,9);
   11676                     // src/com/google/doclava/parser/Java.g:1135:9: ( '[' ']' )+
   11677                     int cnt141=0;
   11678                     try { dbg.enterSubRule(141);
   11679 
   11680                     loop141:
   11681                     do {
   11682                         int alt141=2;
   11683                         try { dbg.enterDecision(141, decisionCanBacktrack[141]);
   11684 
   11685                         int LA141_0 = input.LA(1);
   11686 
   11687                         if ( (LA141_0==LBRACKET) ) {
   11688                             alt141=1;
   11689                         }
   11690 
   11691 
   11692                         } finally {dbg.exitDecision(141);}
   11693 
   11694                         switch (alt141) {
   11695 			case 1 :
   11696 			    dbg.enterAlt(1);
   11697 
   11698 			    // src/com/google/doclava/parser/Java.g:1135:10: '[' ']'
   11699 			    {
   11700 			    dbg.location(1135,10);
   11701 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix6620); if (state.failed) return ;
   11702 			    dbg.location(1135,14);
   11703 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix6622); if (state.failed) return ;
   11704 
   11705 			    }
   11706 			    break;
   11707 
   11708 			default :
   11709 			    if ( cnt141 >= 1 ) break loop141;
   11710 			    if (state.backtracking>0) {state.failed=true; return ;}
   11711                                 EarlyExitException eee =
   11712                                     new EarlyExitException(141, input);
   11713                                 dbg.recognitionException(eee);
   11714 
   11715                                 throw eee;
   11716                         }
   11717                         cnt141++;
   11718                     } while (true);
   11719                     } finally {dbg.exitSubRule(141);}
   11720 
   11721                     dbg.location(1137,9);
   11722                     match(input,DOT,FOLLOW_DOT_in_identifierSuffix6643); if (state.failed) return ;
   11723                     dbg.location(1137,13);
   11724                     match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix6645); if (state.failed) return ;
   11725 
   11726                     }
   11727                     break;
   11728                 case 2 :
   11729                     dbg.enterAlt(2);
   11730 
   11731                     // src/com/google/doclava/parser/Java.g:1138:9: ( '[' expression ']' )+
   11732                     {
   11733                     dbg.location(1138,9);
   11734                     // src/com/google/doclava/parser/Java.g:1138:9: ( '[' expression ']' )+
   11735                     int cnt142=0;
   11736                     try { dbg.enterSubRule(142);
   11737 
   11738                     loop142:
   11739                     do {
   11740                         int alt142=2;
   11741                         try { dbg.enterDecision(142, decisionCanBacktrack[142]);
   11742 
   11743                         try {
   11744                             isCyclicDecision = true;
   11745                             alt142 = dfa142.predict(input);
   11746                         }
   11747                         catch (NoViableAltException nvae) {
   11748                             dbg.recognitionException(nvae);
   11749                             throw nvae;
   11750                         }
   11751                         } finally {dbg.exitDecision(142);}
   11752 
   11753                         switch (alt142) {
   11754 			case 1 :
   11755 			    dbg.enterAlt(1);
   11756 
   11757 			    // src/com/google/doclava/parser/Java.g:1138:10: '[' expression ']'
   11758 			    {
   11759 			    dbg.location(1138,10);
   11760 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix6656); if (state.failed) return ;
   11761 			    dbg.location(1138,14);
   11762 			    pushFollow(FOLLOW_expression_in_identifierSuffix6658);
   11763 			    expression();
   11764 
   11765 			    state._fsp--;
   11766 			    if (state.failed) return ;
   11767 			    dbg.location(1138,25);
   11768 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix6660); if (state.failed) return ;
   11769 
   11770 			    }
   11771 			    break;
   11772 
   11773 			default :
   11774 			    if ( cnt142 >= 1 ) break loop142;
   11775 			    if (state.backtracking>0) {state.failed=true; return ;}
   11776                                 EarlyExitException eee =
   11777                                     new EarlyExitException(142, input);
   11778                                 dbg.recognitionException(eee);
   11779 
   11780                                 throw eee;
   11781                         }
   11782                         cnt142++;
   11783                     } while (true);
   11784                     } finally {dbg.exitSubRule(142);}
   11785 
   11786 
   11787                     }
   11788                     break;
   11789                 case 3 :
   11790                     dbg.enterAlt(3);
   11791 
   11792                     // src/com/google/doclava/parser/Java.g:1140:9: arguments
   11793                     {
   11794                     dbg.location(1140,9);
   11795                     pushFollow(FOLLOW_arguments_in_identifierSuffix6681);
   11796                     arguments();
   11797 
   11798                     state._fsp--;
   11799                     if (state.failed) return ;
   11800 
   11801                     }
   11802                     break;
   11803                 case 4 :
   11804                     dbg.enterAlt(4);
   11805 
   11806                     // src/com/google/doclava/parser/Java.g:1141:9: '.' 'class'
   11807                     {
   11808                     dbg.location(1141,9);
   11809                     match(input,DOT,FOLLOW_DOT_in_identifierSuffix6691); if (state.failed) return ;
   11810                     dbg.location(1141,13);
   11811                     match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix6693); if (state.failed) return ;
   11812 
   11813                     }
   11814                     break;
   11815                 case 5 :
   11816                     dbg.enterAlt(5);
   11817 
   11818                     // src/com/google/doclava/parser/Java.g:1142:9: '.' nonWildcardTypeArguments IDENTIFIER arguments
   11819                     {
   11820                     dbg.location(1142,9);
   11821                     match(input,DOT,FOLLOW_DOT_in_identifierSuffix6703); if (state.failed) return ;
   11822                     dbg.location(1142,13);
   11823                     pushFollow(FOLLOW_nonWildcardTypeArguments_in_identifierSuffix6705);
   11824                     nonWildcardTypeArguments();
   11825 
   11826                     state._fsp--;
   11827                     if (state.failed) return ;
   11828                     dbg.location(1142,38);
   11829                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifierSuffix6707); if (state.failed) return ;
   11830                     dbg.location(1142,49);
   11831                     pushFollow(FOLLOW_arguments_in_identifierSuffix6709);
   11832                     arguments();
   11833 
   11834                     state._fsp--;
   11835                     if (state.failed) return ;
   11836 
   11837                     }
   11838                     break;
   11839                 case 6 :
   11840                     dbg.enterAlt(6);
   11841 
   11842                     // src/com/google/doclava/parser/Java.g:1143:9: '.' 'this'
   11843                     {
   11844                     dbg.location(1143,9);
   11845                     match(input,DOT,FOLLOW_DOT_in_identifierSuffix6719); if (state.failed) return ;
   11846                     dbg.location(1143,13);
   11847                     match(input,THIS,FOLLOW_THIS_in_identifierSuffix6721); if (state.failed) return ;
   11848 
   11849                     }
   11850                     break;
   11851                 case 7 :
   11852                     dbg.enterAlt(7);
   11853 
   11854                     // src/com/google/doclava/parser/Java.g:1144:9: '.' 'super' arguments
   11855                     {
   11856                     dbg.location(1144,9);
   11857                     match(input,DOT,FOLLOW_DOT_in_identifierSuffix6731); if (state.failed) return ;
   11858                     dbg.location(1144,13);
   11859                     match(input,SUPER,FOLLOW_SUPER_in_identifierSuffix6733); if (state.failed) return ;
   11860                     dbg.location(1144,21);
   11861                     pushFollow(FOLLOW_arguments_in_identifierSuffix6735);
   11862                     arguments();
   11863 
   11864                     state._fsp--;
   11865                     if (state.failed) return ;
   11866 
   11867                     }
   11868                     break;
   11869                 case 8 :
   11870                     dbg.enterAlt(8);
   11871 
   11872                     // src/com/google/doclava/parser/Java.g:1145:9: innerCreator
   11873                     {
   11874                     dbg.location(1145,9);
   11875                     pushFollow(FOLLOW_innerCreator_in_identifierSuffix6745);
   11876                     innerCreator();
   11877 
   11878                     state._fsp--;
   11879                     if (state.failed) return ;
   11880 
   11881                     }
   11882                     break;
   11883 
   11884             }
   11885         }
   11886         catch (RecognitionException re) {
   11887             reportError(re);
   11888             recover(input,re);
   11889         }
   11890         finally {
   11891             if ( state.backtracking>0 ) { memoize(input, 91, identifierSuffix_StartIndex); }
   11892         }
   11893         dbg.location(1146, 5);
   11894 
   11895         }
   11896         finally {
   11897             dbg.exitRule(getGrammarFileName(), "identifierSuffix");
   11898             decRuleLevel();
   11899             if ( getRuleLevel()==0 ) {dbg.terminate();}
   11900         }
   11901 
   11902         return ;
   11903     }
   11904     // $ANTLR end "identifierSuffix"
   11905 
   11906 
   11907     // $ANTLR start "selector"
   11908     // src/com/google/doclava/parser/Java.g:1149:1: selector : ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' );
   11909     public final void selector() throws RecognitionException {
   11910         int selector_StartIndex = input.index();
   11911         try { dbg.enterRule(getGrammarFileName(), "selector");
   11912         if ( getRuleLevel()==0 ) {dbg.commence();}
   11913         incRuleLevel();
   11914         dbg.location(1149, 1);
   11915 
   11916         try {
   11917             if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return ; }
   11918             // src/com/google/doclava/parser/Java.g:1150:5: ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' )
   11919             int alt145=5;
   11920             try { dbg.enterDecision(145, decisionCanBacktrack[145]);
   11921 
   11922             int LA145_0 = input.LA(1);
   11923 
   11924             if ( (LA145_0==DOT) ) {
   11925                 switch ( input.LA(2) ) {
   11926                 case IDENTIFIER:
   11927                     {
   11928                     alt145=1;
   11929                     }
   11930                     break;
   11931                 case THIS:
   11932                     {
   11933                     alt145=2;
   11934                     }
   11935                     break;
   11936                 case SUPER:
   11937                     {
   11938                     alt145=3;
   11939                     }
   11940                     break;
   11941                 case NEW:
   11942                     {
   11943                     alt145=4;
   11944                     }
   11945                     break;
   11946                 default:
   11947                     if (state.backtracking>0) {state.failed=true; return ;}
   11948                     NoViableAltException nvae =
   11949                         new NoViableAltException("", 145, 1, input);
   11950 
   11951                     dbg.recognitionException(nvae);
   11952                     throw nvae;
   11953                 }
   11954 
   11955             }
   11956             else if ( (LA145_0==LBRACKET) ) {
   11957                 alt145=5;
   11958             }
   11959             else {
   11960                 if (state.backtracking>0) {state.failed=true; return ;}
   11961                 NoViableAltException nvae =
   11962                     new NoViableAltException("", 145, 0, input);
   11963 
   11964                 dbg.recognitionException(nvae);
   11965                 throw nvae;
   11966             }
   11967             } finally {dbg.exitDecision(145);}
   11968 
   11969             switch (alt145) {
   11970                 case 1 :
   11971                     dbg.enterAlt(1);
   11972 
   11973                     // src/com/google/doclava/parser/Java.g:1150:9: '.' IDENTIFIER ( arguments )?
   11974                     {
   11975                     dbg.location(1150,9);
   11976                     match(input,DOT,FOLLOW_DOT_in_selector6765); if (state.failed) return ;
   11977                     dbg.location(1150,13);
   11978                     match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_selector6767); if (state.failed) return ;
   11979                     dbg.location(1151,9);
   11980                     // src/com/google/doclava/parser/Java.g:1151:9: ( arguments )?
   11981                     int alt144=2;
   11982                     try { dbg.enterSubRule(144);
   11983                     try { dbg.enterDecision(144, decisionCanBacktrack[144]);
   11984 
   11985                     int LA144_0 = input.LA(1);
   11986 
   11987                     if ( (LA144_0==LPAREN) ) {
   11988                         alt144=1;
   11989                     }
   11990                     } finally {dbg.exitDecision(144);}
   11991 
   11992                     switch (alt144) {
   11993                         case 1 :
   11994                             dbg.enterAlt(1);
   11995 
   11996                             // src/com/google/doclava/parser/Java.g:1151:10: arguments
   11997                             {
   11998                             dbg.location(1151,10);
   11999                             pushFollow(FOLLOW_arguments_in_selector6778);
   12000                             arguments();
   12001 
   12002                             state._fsp--;
   12003                             if (state.failed) return ;
   12004 
   12005                             }
   12006                             break;
   12007 
   12008                     }
   12009                     } finally {dbg.exitSubRule(144);}
   12010 
   12011 
   12012                     }
   12013                     break;
   12014                 case 2 :
   12015                     dbg.enterAlt(2);
   12016 
   12017                     // src/com/google/doclava/parser/Java.g:1153:9: '.' 'this'
   12018                     {
   12019                     dbg.location(1153,9);
   12020                     match(input,DOT,FOLLOW_DOT_in_selector6799); if (state.failed) return ;
   12021                     dbg.location(1153,13);
   12022                     match(input,THIS,FOLLOW_THIS_in_selector6801); if (state.failed) return ;
   12023 
   12024                     }
   12025                     break;
   12026                 case 3 :
   12027                     dbg.enterAlt(3);
   12028 
   12029                     // src/com/google/doclava/parser/Java.g:1154:9: '.' 'super' superSuffix
   12030                     {
   12031                     dbg.location(1154,9);
   12032                     match(input,DOT,FOLLOW_DOT_in_selector6811); if (state.failed) return ;
   12033                     dbg.location(1154,13);
   12034                     match(input,SUPER,FOLLOW_SUPER_in_selector6813); if (state.failed) return ;
   12035                     dbg.location(1155,9);
   12036                     pushFollow(FOLLOW_superSuffix_in_selector6823);
   12037                     superSuffix();
   12038 
   12039                     state._fsp--;
   12040                     if (state.failed) return ;
   12041 
   12042                     }
   12043                     break;
   12044                 case 4 :
   12045                     dbg.enterAlt(4);
   12046 
   12047                     // src/com/google/doclava/parser/Java.g:1156:9: innerCreator
   12048                     {
   12049                     dbg.location(1156,9);
   12050                     pushFollow(FOLLOW_innerCreator_in_selector6833);
   12051                     innerCreator();
   12052 
   12053                     state._fsp--;
   12054                     if (state.failed) return ;
   12055 
   12056                     }
   12057                     break;
   12058                 case 5 :
   12059                     dbg.enterAlt(5);
   12060 
   12061                     // src/com/google/doclava/parser/Java.g:1157:9: '[' expression ']'
   12062                     {
   12063                     dbg.location(1157,9);
   12064                     match(input,LBRACKET,FOLLOW_LBRACKET_in_selector6843); if (state.failed) return ;
   12065                     dbg.location(1157,13);
   12066                     pushFollow(FOLLOW_expression_in_selector6845);
   12067                     expression();
   12068 
   12069                     state._fsp--;
   12070                     if (state.failed) return ;
   12071                     dbg.location(1157,24);
   12072                     match(input,RBRACKET,FOLLOW_RBRACKET_in_selector6847); if (state.failed) return ;
   12073 
   12074                     }
   12075                     break;
   12076 
   12077             }
   12078         }
   12079         catch (RecognitionException re) {
   12080             reportError(re);
   12081             recover(input,re);
   12082         }
   12083         finally {
   12084             if ( state.backtracking>0 ) { memoize(input, 92, selector_StartIndex); }
   12085         }
   12086         dbg.location(1158, 5);
   12087 
   12088         }
   12089         finally {
   12090             dbg.exitRule(getGrammarFileName(), "selector");
   12091             decRuleLevel();
   12092             if ( getRuleLevel()==0 ) {dbg.terminate();}
   12093         }
   12094 
   12095         return ;
   12096     }
   12097     // $ANTLR end "selector"
   12098 
   12099 
   12100     // $ANTLR start "creator"
   12101     // src/com/google/doclava/parser/Java.g:1160:1: creator : ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator );
   12102     public final void creator() throws RecognitionException {
   12103         int creator_StartIndex = input.index();
   12104         try { dbg.enterRule(getGrammarFileName(), "creator");
   12105         if ( getRuleLevel()==0 ) {dbg.commence();}
   12106         incRuleLevel();
   12107         dbg.location(1160, 1);
   12108 
   12109         try {
   12110             if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return ; }
   12111             // src/com/google/doclava/parser/Java.g:1161:5: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator )
   12112             int alt146=3;
   12113             try { dbg.enterDecision(146, decisionCanBacktrack[146]);
   12114 
   12115             int LA146_0 = input.LA(1);
   12116 
   12117             if ( (LA146_0==NEW) ) {
   12118                 int LA146_1 = input.LA(2);
   12119 
   12120                 if ( (synpred236_Java()) ) {
   12121                     alt146=1;
   12122                 }
   12123                 else if ( (synpred237_Java()) ) {
   12124                     alt146=2;
   12125                 }
   12126                 else if ( (true) ) {
   12127                     alt146=3;
   12128                 }
   12129                 else {
   12130                     if (state.backtracking>0) {state.failed=true; return ;}
   12131                     NoViableAltException nvae =
   12132                         new NoViableAltException("", 146, 1, input);
   12133 
   12134                     dbg.recognitionException(nvae);
   12135                     throw nvae;
   12136                 }
   12137             }
   12138             else {
   12139                 if (state.backtracking>0) {state.failed=true; return ;}
   12140                 NoViableAltException nvae =
   12141                     new NoViableAltException("", 146, 0, input);
   12142 
   12143                 dbg.recognitionException(nvae);
   12144                 throw nvae;
   12145             }
   12146             } finally {dbg.exitDecision(146);}
   12147 
   12148             switch (alt146) {
   12149                 case 1 :
   12150                     dbg.enterAlt(1);
   12151 
   12152                     // src/com/google/doclava/parser/Java.g:1161:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest
   12153                     {
   12154                     dbg.location(1161,9);
   12155                     match(input,NEW,FOLLOW_NEW_in_creator6866); if (state.failed) return ;
   12156                     dbg.location(1161,15);
   12157                     pushFollow(FOLLOW_nonWildcardTypeArguments_in_creator6868);
   12158                     nonWildcardTypeArguments();
   12159 
   12160                     state._fsp--;
   12161                     if (state.failed) return ;
   12162                     dbg.location(1161,40);
   12163                     pushFollow(FOLLOW_classOrInterfaceType_in_creator6870);
   12164                     classOrInterfaceType();
   12165 
   12166                     state._fsp--;
   12167                     if (state.failed) return ;
   12168                     dbg.location(1161,61);
   12169                     pushFollow(FOLLOW_classCreatorRest_in_creator6872);
   12170                     classCreatorRest();
   12171 
   12172                     state._fsp--;
   12173                     if (state.failed) return ;
   12174 
   12175                     }
   12176                     break;
   12177                 case 2 :
   12178                     dbg.enterAlt(2);
   12179 
   12180                     // src/com/google/doclava/parser/Java.g:1162:9: 'new' classOrInterfaceType classCreatorRest
   12181                     {
   12182                     dbg.location(1162,9);
   12183                     match(input,NEW,FOLLOW_NEW_in_creator6882); if (state.failed) return ;
   12184                     dbg.location(1162,15);
   12185                     pushFollow(FOLLOW_classOrInterfaceType_in_creator6884);
   12186                     classOrInterfaceType();
   12187 
   12188                     state._fsp--;
   12189                     if (state.failed) return ;
   12190                     dbg.location(1162,36);
   12191                     pushFollow(FOLLOW_classCreatorRest_in_creator6886);
   12192                     classCreatorRest();
   12193 
   12194                     state._fsp--;
   12195                     if (state.failed) return ;
   12196 
   12197                     }
   12198                     break;
   12199                 case 3 :
   12200                     dbg.enterAlt(3);
   12201 
   12202                     // src/com/google/doclava/parser/Java.g:1163:9: arrayCreator
   12203                     {
   12204                     dbg.location(1163,9);
   12205                     pushFollow(FOLLOW_arrayCreator_in_creator6896);
   12206                     arrayCreator();
   12207 
   12208                     state._fsp--;
   12209                     if (state.failed) return ;
   12210 
   12211                     }
   12212                     break;
   12213 
   12214             }
   12215         }
   12216         catch (RecognitionException re) {
   12217             reportError(re);
   12218             recover(input,re);
   12219         }
   12220         finally {
   12221             if ( state.backtracking>0 ) { memoize(input, 93, creator_StartIndex); }
   12222         }
   12223         dbg.location(1164, 5);
   12224 
   12225         }
   12226         finally {
   12227             dbg.exitRule(getGrammarFileName(), "creator");
   12228             decRuleLevel();
   12229             if ( getRuleLevel()==0 ) {dbg.terminate();}
   12230         }
   12231 
   12232         return ;
   12233     }
   12234     // $ANTLR end "creator"
   12235 
   12236 
   12237     // $ANTLR start "arrayCreator"
   12238     // src/com/google/doclava/parser/Java.g:1166:1: arrayCreator : ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* );
   12239     public final void arrayCreator() throws RecognitionException {
   12240         int arrayCreator_StartIndex = input.index();
   12241         try { dbg.enterRule(getGrammarFileName(), "arrayCreator");
   12242         if ( getRuleLevel()==0 ) {dbg.commence();}
   12243         incRuleLevel();
   12244         dbg.location(1166, 1);
   12245 
   12246         try {
   12247             if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return ; }
   12248             // src/com/google/doclava/parser/Java.g:1167:5: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* )
   12249             int alt150=2;
   12250             try { dbg.enterDecision(150, decisionCanBacktrack[150]);
   12251 
   12252             int LA150_0 = input.LA(1);
   12253 
   12254             if ( (LA150_0==NEW) ) {
   12255                 int LA150_1 = input.LA(2);
   12256 
   12257                 if ( (synpred239_Java()) ) {
   12258                     alt150=1;
   12259                 }
   12260                 else if ( (true) ) {
   12261                     alt150=2;
   12262                 }
   12263                 else {
   12264                     if (state.backtracking>0) {state.failed=true; return ;}
   12265                     NoViableAltException nvae =
   12266                         new NoViableAltException("", 150, 1, input);
   12267 
   12268                     dbg.recognitionException(nvae);
   12269                     throw nvae;
   12270                 }
   12271             }
   12272             else {
   12273                 if (state.backtracking>0) {state.failed=true; return ;}
   12274                 NoViableAltException nvae =
   12275                     new NoViableAltException("", 150, 0, input);
   12276 
   12277                 dbg.recognitionException(nvae);
   12278                 throw nvae;
   12279             }
   12280             } finally {dbg.exitDecision(150);}
   12281 
   12282             switch (alt150) {
   12283                 case 1 :
   12284                     dbg.enterAlt(1);
   12285 
   12286                     // src/com/google/doclava/parser/Java.g:1167:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer
   12287                     {
   12288                     dbg.location(1167,9);
   12289                     match(input,NEW,FOLLOW_NEW_in_arrayCreator6915); if (state.failed) return ;
   12290                     dbg.location(1167,15);
   12291                     pushFollow(FOLLOW_createdName_in_arrayCreator6917);
   12292                     createdName();
   12293 
   12294                     state._fsp--;
   12295                     if (state.failed) return ;
   12296                     dbg.location(1168,9);
   12297                     match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6927); if (state.failed) return ;
   12298                     dbg.location(1168,13);
   12299                     match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6929); if (state.failed) return ;
   12300                     dbg.location(1169,9);
   12301                     // src/com/google/doclava/parser/Java.g:1169:9: ( '[' ']' )*
   12302                     try { dbg.enterSubRule(147);
   12303 
   12304                     loop147:
   12305                     do {
   12306                         int alt147=2;
   12307                         try { dbg.enterDecision(147, decisionCanBacktrack[147]);
   12308 
   12309                         int LA147_0 = input.LA(1);
   12310 
   12311                         if ( (LA147_0==LBRACKET) ) {
   12312                             alt147=1;
   12313                         }
   12314 
   12315 
   12316                         } finally {dbg.exitDecision(147);}
   12317 
   12318                         switch (alt147) {
   12319 			case 1 :
   12320 			    dbg.enterAlt(1);
   12321 
   12322 			    // src/com/google/doclava/parser/Java.g:1169:10: '[' ']'
   12323 			    {
   12324 			    dbg.location(1169,10);
   12325 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6940); if (state.failed) return ;
   12326 			    dbg.location(1169,14);
   12327 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6942); if (state.failed) return ;
   12328 
   12329 			    }
   12330 			    break;
   12331 
   12332 			default :
   12333 			    break loop147;
   12334                         }
   12335                     } while (true);
   12336                     } finally {dbg.exitSubRule(147);}
   12337 
   12338                     dbg.location(1171,9);
   12339                     pushFollow(FOLLOW_arrayInitializer_in_arrayCreator6963);
   12340                     arrayInitializer();
   12341 
   12342                     state._fsp--;
   12343                     if (state.failed) return ;
   12344 
   12345                     }
   12346                     break;
   12347                 case 2 :
   12348                     dbg.enterAlt(2);
   12349 
   12350                     // src/com/google/doclava/parser/Java.g:1173:9: 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )*
   12351                     {
   12352                     dbg.location(1173,9);
   12353                     match(input,NEW,FOLLOW_NEW_in_arrayCreator6974); if (state.failed) return ;
   12354                     dbg.location(1173,15);
   12355                     pushFollow(FOLLOW_createdName_in_arrayCreator6976);
   12356                     createdName();
   12357 
   12358                     state._fsp--;
   12359                     if (state.failed) return ;
   12360                     dbg.location(1174,9);
   12361                     match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6986); if (state.failed) return ;
   12362                     dbg.location(1174,13);
   12363                     pushFollow(FOLLOW_expression_in_arrayCreator6988);
   12364                     expression();
   12365 
   12366                     state._fsp--;
   12367                     if (state.failed) return ;
   12368                     dbg.location(1175,9);
   12369                     match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6998); if (state.failed) return ;
   12370                     dbg.location(1176,9);
   12371                     // src/com/google/doclava/parser/Java.g:1176:9: ( '[' expression ']' )*
   12372                     try { dbg.enterSubRule(148);
   12373 
   12374                     loop148:
   12375                     do {
   12376                         int alt148=2;
   12377                         try { dbg.enterDecision(148, decisionCanBacktrack[148]);
   12378 
   12379                         try {
   12380                             isCyclicDecision = true;
   12381                             alt148 = dfa148.predict(input);
   12382                         }
   12383                         catch (NoViableAltException nvae) {
   12384                             dbg.recognitionException(nvae);
   12385                             throw nvae;
   12386                         }
   12387                         } finally {dbg.exitDecision(148);}
   12388 
   12389                         switch (alt148) {
   12390 			case 1 :
   12391 			    dbg.enterAlt(1);
   12392 
   12393 			    // src/com/google/doclava/parser/Java.g:1176:13: '[' expression ']'
   12394 			    {
   12395 			    dbg.location(1176,13);
   12396 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator7012); if (state.failed) return ;
   12397 			    dbg.location(1176,17);
   12398 			    pushFollow(FOLLOW_expression_in_arrayCreator7014);
   12399 			    expression();
   12400 
   12401 			    state._fsp--;
   12402 			    if (state.failed) return ;
   12403 			    dbg.location(1177,13);
   12404 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator7028); if (state.failed) return ;
   12405 
   12406 			    }
   12407 			    break;
   12408 
   12409 			default :
   12410 			    break loop148;
   12411                         }
   12412                     } while (true);
   12413                     } finally {dbg.exitSubRule(148);}
   12414 
   12415                     dbg.location(1179,9);
   12416                     // src/com/google/doclava/parser/Java.g:1179:9: ( '[' ']' )*
   12417                     try { dbg.enterSubRule(149);
   12418 
   12419                     loop149:
   12420                     do {
   12421                         int alt149=2;
   12422                         try { dbg.enterDecision(149, decisionCanBacktrack[149]);
   12423 
   12424                         int LA149_0 = input.LA(1);
   12425 
   12426                         if ( (LA149_0==LBRACKET) ) {
   12427                             int LA149_2 = input.LA(2);
   12428 
   12429                             if ( (LA149_2==RBRACKET) ) {
   12430                                 alt149=1;
   12431                             }
   12432 
   12433 
   12434                         }
   12435 
   12436 
   12437                         } finally {dbg.exitDecision(149);}
   12438 
   12439                         switch (alt149) {
   12440 			case 1 :
   12441 			    dbg.enterAlt(1);
   12442 
   12443 			    // src/com/google/doclava/parser/Java.g:1179:10: '[' ']'
   12444 			    {
   12445 			    dbg.location(1179,10);
   12446 			    match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator7050); if (state.failed) return ;
   12447 			    dbg.location(1179,14);
   12448 			    match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator7052); if (state.failed) return ;
   12449 
   12450 			    }
   12451 			    break;
   12452 
   12453 			default :
   12454 			    break loop149;
   12455                         }
   12456                     } while (true);
   12457                     } finally {dbg.exitSubRule(149);}
   12458 
   12459 
   12460                     }
   12461                     break;
   12462 
   12463             }
   12464         }
   12465         catch (RecognitionException re) {
   12466             reportError(re);
   12467             recover(input,re);
   12468         }
   12469         finally {
   12470             if ( state.backtracking>0 ) { memoize(input, 94, arrayCreator_StartIndex); }
   12471         }
   12472         dbg.location(1181, 5);
   12473 
   12474         }
   12475         finally {
   12476             dbg.exitRule(getGrammarFileName(), "arrayCreator");
   12477             decRuleLevel();
   12478             if ( getRuleLevel()==0 ) {dbg.terminate();}
   12479         }
   12480 
   12481         return ;
   12482     }
   12483     // $ANTLR end "arrayCreator"
   12484 
   12485 
   12486     // $ANTLR start "variableInitializer"
   12487     // src/com/google/doclava/parser/Java.g:1183:1: variableInitializer : ( arrayInitializer | expression );
   12488     public final void variableInitializer() throws RecognitionException {
   12489         int variableInitializer_StartIndex = input.index();
   12490         try { dbg.enterRule(getGrammarFileName(), "variableInitializer");
   12491         if ( getRuleLevel()==0 ) {dbg.commence();}
   12492         incRuleLevel();
   12493         dbg.location(1183, 1);
   12494 
   12495         try {
   12496             if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return ; }
   12497             // src/com/google/doclava/parser/Java.g:1184:5: ( arrayInitializer | expression )
   12498             int alt151=2;
   12499             try { dbg.enterDecision(151, decisionCanBacktrack[151]);
   12500 
   12501             int LA151_0 = input.LA(1);
   12502 
   12503             if ( (LA151_0==LBRACE) ) {
   12504                 alt151=1;
   12505             }
   12506             else if ( ((LA151_0>=IDENTIFIER && LA151_0<=NULL)||LA151_0==BOOLEAN||LA151_0==BYTE||LA151_0==CHAR||LA151_0==DOUBLE||LA151_0==FLOAT||LA151_0==INT||LA151_0==LONG||LA151_0==NEW||LA151_0==SHORT||LA151_0==SUPER||LA151_0==THIS||LA151_0==VOID||LA151_0==LPAREN||(LA151_0>=BANG && LA151_0<=TILDE)||(LA151_0>=PLUSPLUS && LA151_0<=SUB)) ) {
   12507                 alt151=2;
   12508             }
   12509             else {
   12510                 if (state.backtracking>0) {state.failed=true; return ;}
   12511                 NoViableAltException nvae =
   12512                     new NoViableAltException("", 151, 0, input);
   12513 
   12514                 dbg.recognitionException(nvae);
   12515                 throw nvae;
   12516             }
   12517             } finally {dbg.exitDecision(151);}
   12518 
   12519             switch (alt151) {
   12520                 case 1 :
   12521                     dbg.enterAlt(1);
   12522 
   12523                     // src/com/google/doclava/parser/Java.g:1184:9: arrayInitializer
   12524                     {
   12525                     dbg.location(1184,9);
   12526                     pushFollow(FOLLOW_arrayInitializer_in_variableInitializer7082);
   12527                     arrayInitializer();
   12528 
   12529                     state._fsp--;
   12530                     if (state.failed) return ;
   12531 
   12532                     }
   12533                     break;
   12534                 case 2 :
   12535                     dbg.enterAlt(2);
   12536 
   12537                     // src/com/google/doclava/parser/Java.g:1185:9: expression
   12538                     {
   12539                     dbg.location(1185,9);
   12540                     pushFollow(FOLLOW_expression_in_variableInitializer7092);
   12541                     expression();
   12542 
   12543                     state._fsp--;
   12544                     if (state.failed) return ;
   12545 
   12546                     }
   12547                     break;
   12548 
   12549             }
   12550         }
   12551         catch (RecognitionException re) {
   12552             reportError(re);
   12553             recover(input,re);
   12554         }
   12555         finally {
   12556             if ( state.backtracking>0 ) { memoize(input, 95, variableInitializer_StartIndex); }
   12557         }
   12558         dbg.location(1186, 5);
   12559 
   12560         }
   12561         finally {
   12562             dbg.exitRule(getGrammarFileName(), "variableInitializer");
   12563             decRuleLevel();
   12564             if ( getRuleLevel()==0 ) {dbg.terminate();}
   12565         }
   12566 
   12567         return ;
   12568     }
   12569     // $ANTLR end "variableInitializer"
   12570 
   12571 
   12572     // $ANTLR start "arrayInitializer"
   12573     // src/com/google/doclava/parser/Java.g:1188:1: arrayInitializer : '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' ;
   12574     public final void arrayInitializer() throws RecognitionException {
   12575         int arrayInitializer_StartIndex = input.index();
   12576         try { dbg.enterRule(getGrammarFileName(), "arrayInitializer");
   12577         if ( getRuleLevel()==0 ) {dbg.commence();}
   12578         incRuleLevel();
   12579         dbg.location(1188, 1);
   12580 
   12581         try {
   12582             if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return ; }
   12583             // src/com/google/doclava/parser/Java.g:1189:5: ( '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' )
   12584             dbg.enterAlt(1);
   12585 
   12586             // src/com/google/doclava/parser/Java.g:1189:9: '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}'
   12587             {
   12588             dbg.location(1189,9);
   12589             match(input,LBRACE,FOLLOW_LBRACE_in_arrayInitializer7111); if (state.failed) return ;
   12590             dbg.location(1190,13);
   12591             // src/com/google/doclava/parser/Java.g:1190:13: ( variableInitializer ( ',' variableInitializer )* )?
   12592             int alt153=2;
   12593             try { dbg.enterSubRule(153);
   12594             try { dbg.enterDecision(153, decisionCanBacktrack[153]);
   12595 
   12596             int LA153_0 = input.LA(1);
   12597 
   12598             if ( ((LA153_0>=IDENTIFIER && LA153_0<=NULL)||LA153_0==BOOLEAN||LA153_0==BYTE||LA153_0==CHAR||LA153_0==DOUBLE||LA153_0==FLOAT||LA153_0==INT||LA153_0==LONG||LA153_0==NEW||LA153_0==SHORT||LA153_0==SUPER||LA153_0==THIS||LA153_0==VOID||LA153_0==LPAREN||LA153_0==LBRACE||(LA153_0>=BANG && LA153_0<=TILDE)||(LA153_0>=PLUSPLUS && LA153_0<=SUB)) ) {
   12599                 alt153=1;
   12600             }
   12601             } finally {dbg.exitDecision(153);}
   12602 
   12603             switch (alt153) {
   12604                 case 1 :
   12605                     dbg.enterAlt(1);
   12606 
   12607                     // src/com/google/doclava/parser/Java.g:1190:14: variableInitializer ( ',' variableInitializer )*
   12608                     {
   12609                     dbg.location(1190,14);
   12610                     pushFollow(FOLLOW_variableInitializer_in_arrayInitializer7126);
   12611                     variableInitializer();
   12612 
   12613                     state._fsp--;
   12614                     if (state.failed) return ;
   12615                     dbg.location(1191,17);
   12616                     // src/com/google/doclava/parser/Java.g:1191:17: ( ',' variableInitializer )*
   12617                     try { dbg.enterSubRule(152);
   12618 
   12619                     loop152:
   12620                     do {
   12621                         int alt152=2;
   12622                         try { dbg.enterDecision(152, decisionCanBacktrack[152]);
   12623 
   12624                         int LA152_0 = input.LA(1);
   12625 
   12626                         if ( (LA152_0==COMMA) ) {
   12627                             int LA152_1 = input.LA(2);
   12628 
   12629                             if ( ((LA152_1>=IDENTIFIER && LA152_1<=NULL)||LA152_1==BOOLEAN||LA152_1==BYTE||LA152_1==CHAR||LA152_1==DOUBLE||LA152_1==FLOAT||LA152_1==INT||LA152_1==LONG||LA152_1==NEW||LA152_1==SHORT||LA152_1==SUPER||LA152_1==THIS||LA152_1==VOID||LA152_1==LPAREN||LA152_1==LBRACE||(LA152_1>=BANG && LA152_1<=TILDE)||(LA152_1>=PLUSPLUS && LA152_1<=SUB)) ) {
   12630                                 alt152=1;
   12631                             }
   12632 
   12633 
   12634                         }
   12635 
   12636 
   12637                         } finally {dbg.exitDecision(152);}
   12638 
   12639                         switch (alt152) {
   12640 			case 1 :
   12641 			    dbg.enterAlt(1);
   12642 
   12643 			    // src/com/google/doclava/parser/Java.g:1191:18: ',' variableInitializer
   12644 			    {
   12645 			    dbg.location(1191,18);
   12646 			    match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer7145); if (state.failed) return ;
   12647 			    dbg.location(1191,22);
   12648 			    pushFollow(FOLLOW_variableInitializer_in_arrayInitializer7147);
   12649 			    variableInitializer();
   12650 
   12651 			    state._fsp--;
   12652 			    if (state.failed) return ;
   12653 
   12654 			    }
   12655 			    break;
   12656 
   12657 			default :
   12658 			    break loop152;
   12659                         }
   12660                     } while (true);
   12661                     } finally {dbg.exitSubRule(152);}
   12662 
   12663 
   12664                     }
   12665                     break;
   12666 
   12667             }
   12668             } finally {dbg.exitSubRule(153);}
   12669 
   12670             dbg.location(1194,13);
   12671             // src/com/google/doclava/parser/Java.g:1194:13: ( ',' )?
   12672             int alt154=2;
   12673             try { dbg.enterSubRule(154);
   12674             try { dbg.enterDecision(154, decisionCanBacktrack[154]);
   12675 
   12676             int LA154_0 = input.LA(1);
   12677 
   12678             if ( (LA154_0==COMMA) ) {
   12679                 alt154=1;
   12680             }
   12681             } finally {dbg.exitDecision(154);}
   12682 
   12683             switch (alt154) {
   12684                 case 1 :
   12685                     dbg.enterAlt(1);
   12686 
   12687                     // src/com/google/doclava/parser/Java.g:1194:14: ','
   12688                     {
   12689                     dbg.location(1194,14);
   12690                     match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer7196); if (state.failed) return ;
   12691 
   12692                     }
   12693                     break;
   12694 
   12695             }
   12696             } finally {dbg.exitSubRule(154);}
   12697 
   12698             dbg.location(1195,9);
   12699             match(input,RBRACE,FOLLOW_RBRACE_in_arrayInitializer7208); if (state.failed) return ;
   12700 
   12701             }
   12702 
   12703         }
   12704         catch (RecognitionException re) {
   12705             reportError(re);
   12706             recover(input,re);
   12707         }
   12708         finally {
   12709             if ( state.backtracking>0 ) { memoize(input, 96, arrayInitializer_StartIndex); }
   12710         }
   12711         dbg.location(1196, 5);
   12712 
   12713         }
   12714         finally {
   12715             dbg.exitRule(getGrammarFileName(), "arrayInitializer");
   12716             decRuleLevel();
   12717             if ( getRuleLevel()==0 ) {dbg.terminate();}
   12718         }
   12719 
   12720         return ;
   12721     }
   12722     // $ANTLR end "arrayInitializer"
   12723 
   12724 
   12725     // $ANTLR start "createdName"
   12726     // src/com/google/doclava/parser/Java.g:1199:1: createdName : ( classOrInterfaceType | primitiveType );
   12727     public final void createdName() throws RecognitionException {
   12728         int createdName_StartIndex = input.index();
   12729         try { dbg.enterRule(getGrammarFileName(), "createdName");
   12730         if ( getRuleLevel()==0 ) {dbg.commence();}
   12731         incRuleLevel();
   12732         dbg.location(1199, 1);
   12733 
   12734         try {
   12735             if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return ; }
   12736             // src/com/google/doclava/parser/Java.g:1200:5: ( classOrInterfaceType | primitiveType )
   12737             int alt155=2;
   12738             try { dbg.enterDecision(155, decisionCanBacktrack[155]);
   12739 
   12740             int LA155_0 = input.LA(1);
   12741 
   12742             if ( (LA155_0==IDENTIFIER) ) {
   12743                 alt155=1;
   12744             }
   12745             else if ( (LA155_0==BOOLEAN||LA155_0==BYTE||LA155_0==CHAR||LA155_0==DOUBLE||LA155_0==FLOAT||LA155_0==INT||LA155_0==LONG||LA155_0==SHORT) ) {
   12746                 alt155=2;
   12747             }
   12748             else {
   12749                 if (state.backtracking>0) {state.failed=true; return ;}
   12750                 NoViableAltException nvae =
   12751                     new NoViableAltException("", 155, 0, input);
   12752 
   12753                 dbg.recognitionException(nvae);
   12754                 throw nvae;
   12755             }
   12756             } finally {dbg.exitDecision(155);}
   12757 
   12758             switch (alt155) {
   12759                 case 1 :
   12760                     dbg.enterAlt(1);
   12761 
   12762                     // src/com/google/doclava/parser/Java.g:1200:9: classOrInterfaceType
   12763                     {
   12764                     dbg.location(1200,9);
   12765                     pushFollow(FOLLOW_classOrInterfaceType_in_createdName7241);
   12766                     classOrInterfaceType();
   12767 
   12768                     state._fsp--;
   12769                     if (state.failed) return ;
   12770 
   12771                     }
   12772                     break;
   12773                 case 2 :
   12774                     dbg.enterAlt(2);
   12775 
   12776                     // src/com/google/doclava/parser/Java.g:1201:9: primitiveType
   12777                     {
   12778                     dbg.location(1201,9);
   12779                     pushFollow(FOLLOW_primitiveType_in_createdName7251);
   12780                     primitiveType();
   12781 
   12782                     state._fsp--;
   12783                     if (state.failed) return ;
   12784 
   12785                     }
   12786                     break;
   12787 
   12788             }
   12789         }
   12790         catch (RecognitionException re) {
   12791             reportError(re);
   12792             recover(input,re);
   12793         }
   12794         finally {
   12795             if ( state.backtracking>0 ) { memoize(input, 97, createdName_StartIndex); }
   12796         }
   12797         dbg.location(1202, 5);
   12798 
   12799         }
   12800         finally {
   12801             dbg.exitRule(getGrammarFileName(), "createdName");
   12802             decRuleLevel();
   12803             if ( getRuleLevel()==0 ) {dbg.terminate();}
   12804         }
   12805 
   12806         return ;
   12807     }
   12808     // $ANTLR end "createdName"
   12809 
   12810 
   12811     // $ANTLR start "innerCreator"
   12812     // src/com/google/doclava/parser/Java.g:1204:1: innerCreator : '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest ;
   12813     public final void innerCreator() throws RecognitionException {
   12814         int innerCreator_StartIndex = input.index();
   12815         try { dbg.enterRule(getGrammarFileName(), "innerCreator");
   12816         if ( getRuleLevel()==0 ) {dbg.commence();}
   12817         incRuleLevel();
   12818         dbg.location(1204, 1);
   12819 
   12820         try {
   12821             if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return ; }
   12822             // src/com/google/doclava/parser/Java.g:1205:5: ( '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest )
   12823             dbg.enterAlt(1);
   12824 
   12825             // src/com/google/doclava/parser/Java.g:1205:9: '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest
   12826             {
   12827             dbg.location(1205,9);
   12828             match(input,DOT,FOLLOW_DOT_in_innerCreator7270); if (state.failed) return ;
   12829             dbg.location(1205,13);
   12830             match(input,NEW,FOLLOW_NEW_in_innerCreator7272); if (state.failed) return ;
   12831             dbg.location(1206,9);
   12832             // src/com/google/doclava/parser/Java.g:1206:9: ( nonWildcardTypeArguments )?
   12833             int alt156=2;
   12834             try { dbg.enterSubRule(156);
   12835             try { dbg.enterDecision(156, decisionCanBacktrack[156]);
   12836 
   12837             int LA156_0 = input.LA(1);
   12838 
   12839             if ( (LA156_0==LT) ) {
   12840                 alt156=1;
   12841             }
   12842             } finally {dbg.exitDecision(156);}
   12843 
   12844             switch (alt156) {
   12845                 case 1 :
   12846                     dbg.enterAlt(1);
   12847 
   12848                     // src/com/google/doclava/parser/Java.g:1206:10: nonWildcardTypeArguments
   12849                     {
   12850                     dbg.location(1206,10);
   12851                     pushFollow(FOLLOW_nonWildcardTypeArguments_in_innerCreator7283);
   12852                     nonWildcardTypeArguments();
   12853 
   12854                     state._fsp--;
   12855                     if (state.failed) return ;
   12856 
   12857                     }
   12858                     break;
   12859 
   12860             }
   12861             } finally {dbg.exitSubRule(156);}
   12862 
   12863             dbg.location(1208,9);
   12864             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_innerCreator7304); if (state.failed) return ;
   12865             dbg.location(1209,9);
   12866             // src/com/google/doclava/parser/Java.g:1209:9: ( typeArguments )?
   12867             int alt157=2;
   12868             try { dbg.enterSubRule(157);
   12869             try { dbg.enterDecision(157, decisionCanBacktrack[157]);
   12870 
   12871             int LA157_0 = input.LA(1);
   12872 
   12873             if ( (LA157_0==LT) ) {
   12874                 alt157=1;
   12875             }
   12876             } finally {dbg.exitDecision(157);}
   12877 
   12878             switch (alt157) {
   12879                 case 1 :
   12880                     dbg.enterAlt(1);
   12881 
   12882                     // src/com/google/doclava/parser/Java.g:1209:10: typeArguments
   12883                     {
   12884                     dbg.location(1209,10);
   12885                     pushFollow(FOLLOW_typeArguments_in_innerCreator7315);
   12886                     typeArguments();
   12887 
   12888                     state._fsp--;
   12889                     if (state.failed) return ;
   12890 
   12891                     }
   12892                     break;
   12893 
   12894             }
   12895             } finally {dbg.exitSubRule(157);}
   12896 
   12897             dbg.location(1211,9);
   12898             pushFollow(FOLLOW_classCreatorRest_in_innerCreator7336);
   12899             classCreatorRest();
   12900 
   12901             state._fsp--;
   12902             if (state.failed) return ;
   12903 
   12904             }
   12905 
   12906         }
   12907         catch (RecognitionException re) {
   12908             reportError(re);
   12909             recover(input,re);
   12910         }
   12911         finally {
   12912             if ( state.backtracking>0 ) { memoize(input, 98, innerCreator_StartIndex); }
   12913         }
   12914         dbg.location(1212, 5);
   12915 
   12916         }
   12917         finally {
   12918             dbg.exitRule(getGrammarFileName(), "innerCreator");
   12919             decRuleLevel();
   12920             if ( getRuleLevel()==0 ) {dbg.terminate();}
   12921         }
   12922 
   12923         return ;
   12924     }
   12925     // $ANTLR end "innerCreator"
   12926 
   12927 
   12928     // $ANTLR start "classCreatorRest"
   12929     // src/com/google/doclava/parser/Java.g:1215:1: classCreatorRest : arguments ( classBody )? ;
   12930     public final void classCreatorRest() throws RecognitionException {
   12931         int classCreatorRest_StartIndex = input.index();
   12932         try { dbg.enterRule(getGrammarFileName(), "classCreatorRest");
   12933         if ( getRuleLevel()==0 ) {dbg.commence();}
   12934         incRuleLevel();
   12935         dbg.location(1215, 1);
   12936 
   12937         try {
   12938             if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return ; }
   12939             // src/com/google/doclava/parser/Java.g:1216:5: ( arguments ( classBody )? )
   12940             dbg.enterAlt(1);
   12941 
   12942             // src/com/google/doclava/parser/Java.g:1216:9: arguments ( classBody )?
   12943             {
   12944             dbg.location(1216,9);
   12945             pushFollow(FOLLOW_arguments_in_classCreatorRest7356);
   12946             arguments();
   12947 
   12948             state._fsp--;
   12949             if (state.failed) return ;
   12950             dbg.location(1217,9);
   12951             // src/com/google/doclava/parser/Java.g:1217:9: ( classBody )?
   12952             int alt158=2;
   12953             try { dbg.enterSubRule(158);
   12954             try { dbg.enterDecision(158, decisionCanBacktrack[158]);
   12955 
   12956             int LA158_0 = input.LA(1);
   12957 
   12958             if ( (LA158_0==LBRACE) ) {
   12959                 alt158=1;
   12960             }
   12961             } finally {dbg.exitDecision(158);}
   12962 
   12963             switch (alt158) {
   12964                 case 1 :
   12965                     dbg.enterAlt(1);
   12966 
   12967                     // src/com/google/doclava/parser/Java.g:1217:10: classBody
   12968                     {
   12969                     dbg.location(1217,10);
   12970                     pushFollow(FOLLOW_classBody_in_classCreatorRest7367);
   12971                     classBody();
   12972 
   12973                     state._fsp--;
   12974                     if (state.failed) return ;
   12975 
   12976                     }
   12977                     break;
   12978 
   12979             }
   12980             } finally {dbg.exitSubRule(158);}
   12981 
   12982 
   12983             }
   12984 
   12985         }
   12986         catch (RecognitionException re) {
   12987             reportError(re);
   12988             recover(input,re);
   12989         }
   12990         finally {
   12991             if ( state.backtracking>0 ) { memoize(input, 99, classCreatorRest_StartIndex); }
   12992         }
   12993         dbg.location(1219, 5);
   12994 
   12995         }
   12996         finally {
   12997             dbg.exitRule(getGrammarFileName(), "classCreatorRest");
   12998             decRuleLevel();
   12999             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13000         }
   13001 
   13002         return ;
   13003     }
   13004     // $ANTLR end "classCreatorRest"
   13005 
   13006 
   13007     // $ANTLR start "nonWildcardTypeArguments"
   13008     // src/com/google/doclava/parser/Java.g:1222:1: nonWildcardTypeArguments : '<' typeList '>' ;
   13009     public final void nonWildcardTypeArguments() throws RecognitionException {
   13010         int nonWildcardTypeArguments_StartIndex = input.index();
   13011         try { dbg.enterRule(getGrammarFileName(), "nonWildcardTypeArguments");
   13012         if ( getRuleLevel()==0 ) {dbg.commence();}
   13013         incRuleLevel();
   13014         dbg.location(1222, 1);
   13015 
   13016         try {
   13017             if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return ; }
   13018             // src/com/google/doclava/parser/Java.g:1223:5: ( '<' typeList '>' )
   13019             dbg.enterAlt(1);
   13020 
   13021             // src/com/google/doclava/parser/Java.g:1223:9: '<' typeList '>'
   13022             {
   13023             dbg.location(1223,9);
   13024             match(input,LT,FOLLOW_LT_in_nonWildcardTypeArguments7398); if (state.failed) return ;
   13025             dbg.location(1223,13);
   13026             pushFollow(FOLLOW_typeList_in_nonWildcardTypeArguments7400);
   13027             typeList();
   13028 
   13029             state._fsp--;
   13030             if (state.failed) return ;
   13031             dbg.location(1224,9);
   13032             match(input,GT,FOLLOW_GT_in_nonWildcardTypeArguments7410); if (state.failed) return ;
   13033 
   13034             }
   13035 
   13036         }
   13037         catch (RecognitionException re) {
   13038             reportError(re);
   13039             recover(input,re);
   13040         }
   13041         finally {
   13042             if ( state.backtracking>0 ) { memoize(input, 100, nonWildcardTypeArguments_StartIndex); }
   13043         }
   13044         dbg.location(1225, 5);
   13045 
   13046         }
   13047         finally {
   13048             dbg.exitRule(getGrammarFileName(), "nonWildcardTypeArguments");
   13049             decRuleLevel();
   13050             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13051         }
   13052 
   13053         return ;
   13054     }
   13055     // $ANTLR end "nonWildcardTypeArguments"
   13056 
   13057 
   13058     // $ANTLR start "arguments"
   13059     // src/com/google/doclava/parser/Java.g:1227:1: arguments : '(' ( expressionList )? ')' ;
   13060     public final void arguments() throws RecognitionException {
   13061         int arguments_StartIndex = input.index();
   13062         try { dbg.enterRule(getGrammarFileName(), "arguments");
   13063         if ( getRuleLevel()==0 ) {dbg.commence();}
   13064         incRuleLevel();
   13065         dbg.location(1227, 1);
   13066 
   13067         try {
   13068             if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return ; }
   13069             // src/com/google/doclava/parser/Java.g:1228:5: ( '(' ( expressionList )? ')' )
   13070             dbg.enterAlt(1);
   13071 
   13072             // src/com/google/doclava/parser/Java.g:1228:9: '(' ( expressionList )? ')'
   13073             {
   13074             dbg.location(1228,9);
   13075             match(input,LPAREN,FOLLOW_LPAREN_in_arguments7429); if (state.failed) return ;
   13076             dbg.location(1228,13);
   13077             // src/com/google/doclava/parser/Java.g:1228:13: ( expressionList )?
   13078             int alt159=2;
   13079             try { dbg.enterSubRule(159);
   13080             try { dbg.enterDecision(159, decisionCanBacktrack[159]);
   13081 
   13082             int LA159_0 = input.LA(1);
   13083 
   13084             if ( ((LA159_0>=IDENTIFIER && LA159_0<=NULL)||LA159_0==BOOLEAN||LA159_0==BYTE||LA159_0==CHAR||LA159_0==DOUBLE||LA159_0==FLOAT||LA159_0==INT||LA159_0==LONG||LA159_0==NEW||LA159_0==SHORT||LA159_0==SUPER||LA159_0==THIS||LA159_0==VOID||LA159_0==LPAREN||(LA159_0>=BANG && LA159_0<=TILDE)||(LA159_0>=PLUSPLUS && LA159_0<=SUB)) ) {
   13085                 alt159=1;
   13086             }
   13087             } finally {dbg.exitDecision(159);}
   13088 
   13089             switch (alt159) {
   13090                 case 1 :
   13091                     dbg.enterAlt(1);
   13092 
   13093                     // src/com/google/doclava/parser/Java.g:1228:14: expressionList
   13094                     {
   13095                     dbg.location(1228,14);
   13096                     pushFollow(FOLLOW_expressionList_in_arguments7432);
   13097                     expressionList();
   13098 
   13099                     state._fsp--;
   13100                     if (state.failed) return ;
   13101 
   13102                     }
   13103                     break;
   13104 
   13105             }
   13106             } finally {dbg.exitSubRule(159);}
   13107 
   13108             dbg.location(1229,12);
   13109             match(input,RPAREN,FOLLOW_RPAREN_in_arguments7445); if (state.failed) return ;
   13110 
   13111             }
   13112 
   13113         }
   13114         catch (RecognitionException re) {
   13115             reportError(re);
   13116             recover(input,re);
   13117         }
   13118         finally {
   13119             if ( state.backtracking>0 ) { memoize(input, 101, arguments_StartIndex); }
   13120         }
   13121         dbg.location(1230, 5);
   13122 
   13123         }
   13124         finally {
   13125             dbg.exitRule(getGrammarFileName(), "arguments");
   13126             decRuleLevel();
   13127             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13128         }
   13129 
   13130         return ;
   13131     }
   13132     // $ANTLR end "arguments"
   13133 
   13134 
   13135     // $ANTLR start "literal"
   13136     // src/com/google/doclava/parser/Java.g:1232:1: literal : ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL );
   13137     public final void literal() throws RecognitionException {
   13138         int literal_StartIndex = input.index();
   13139         try { dbg.enterRule(getGrammarFileName(), "literal");
   13140         if ( getRuleLevel()==0 ) {dbg.commence();}
   13141         incRuleLevel();
   13142         dbg.location(1232, 1);
   13143 
   13144         try {
   13145             if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return ; }
   13146             // src/com/google/doclava/parser/Java.g:1233:5: ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL )
   13147             dbg.enterAlt(1);
   13148 
   13149             // src/com/google/doclava/parser/Java.g:
   13150             {
   13151             dbg.location(1233,5);
   13152             if ( (input.LA(1)>=INTLITERAL && input.LA(1)<=NULL) ) {
   13153                 input.consume();
   13154                 state.errorRecovery=false;state.failed=false;
   13155             }
   13156             else {
   13157                 if (state.backtracking>0) {state.failed=true; return ;}
   13158                 MismatchedSetException mse = new MismatchedSetException(null,input);
   13159                 dbg.recognitionException(mse);
   13160                 throw mse;
   13161             }
   13162 
   13163 
   13164             }
   13165 
   13166         }
   13167         catch (RecognitionException re) {
   13168             reportError(re);
   13169             recover(input,re);
   13170         }
   13171         finally {
   13172             if ( state.backtracking>0 ) { memoize(input, 102, literal_StartIndex); }
   13173         }
   13174         dbg.location(1242, 5);
   13175 
   13176         }
   13177         finally {
   13178             dbg.exitRule(getGrammarFileName(), "literal");
   13179             decRuleLevel();
   13180             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13181         }
   13182 
   13183         return ;
   13184     }
   13185     // $ANTLR end "literal"
   13186 
   13187 
   13188     // $ANTLR start "classHeader"
   13189     // src/com/google/doclava/parser/Java.g:1244:1: classHeader : modifiers 'class' IDENTIFIER ;
   13190     public final void classHeader() throws RecognitionException {
   13191         int classHeader_StartIndex = input.index();
   13192         try { dbg.enterRule(getGrammarFileName(), "classHeader");
   13193         if ( getRuleLevel()==0 ) {dbg.commence();}
   13194         incRuleLevel();
   13195         dbg.location(1244, 1);
   13196 
   13197         try {
   13198             if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return ; }
   13199             // src/com/google/doclava/parser/Java.g:1249:5: ( modifiers 'class' IDENTIFIER )
   13200             dbg.enterAlt(1);
   13201 
   13202             // src/com/google/doclava/parser/Java.g:1249:9: modifiers 'class' IDENTIFIER
   13203             {
   13204             dbg.location(1249,9);
   13205             pushFollow(FOLLOW_modifiers_in_classHeader7566);
   13206             modifiers();
   13207 
   13208             state._fsp--;
   13209             if (state.failed) return ;
   13210             dbg.location(1249,19);
   13211             match(input,CLASS,FOLLOW_CLASS_in_classHeader7568); if (state.failed) return ;
   13212             dbg.location(1249,27);
   13213             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classHeader7570); if (state.failed) return ;
   13214 
   13215             }
   13216 
   13217         }
   13218         catch (RecognitionException re) {
   13219             reportError(re);
   13220             recover(input,re);
   13221         }
   13222         finally {
   13223             if ( state.backtracking>0 ) { memoize(input, 103, classHeader_StartIndex); }
   13224         }
   13225         dbg.location(1250, 5);
   13226 
   13227         }
   13228         finally {
   13229             dbg.exitRule(getGrammarFileName(), "classHeader");
   13230             decRuleLevel();
   13231             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13232         }
   13233 
   13234         return ;
   13235     }
   13236     // $ANTLR end "classHeader"
   13237 
   13238 
   13239     // $ANTLR start "enumHeader"
   13240     // src/com/google/doclava/parser/Java.g:1252:1: enumHeader : modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER ;
   13241     public final void enumHeader() throws RecognitionException {
   13242         int enumHeader_StartIndex = input.index();
   13243         try { dbg.enterRule(getGrammarFileName(), "enumHeader");
   13244         if ( getRuleLevel()==0 ) {dbg.commence();}
   13245         incRuleLevel();
   13246         dbg.location(1252, 1);
   13247 
   13248         try {
   13249             if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return ; }
   13250             // src/com/google/doclava/parser/Java.g:1253:5: ( modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER )
   13251             dbg.enterAlt(1);
   13252 
   13253             // src/com/google/doclava/parser/Java.g:1253:9: modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER
   13254             {
   13255             dbg.location(1253,9);
   13256             pushFollow(FOLLOW_modifiers_in_enumHeader7589);
   13257             modifiers();
   13258 
   13259             state._fsp--;
   13260             if (state.failed) return ;
   13261             dbg.location(1253,19);
   13262             if ( input.LA(1)==IDENTIFIER||input.LA(1)==ENUM ) {
   13263                 input.consume();
   13264                 state.errorRecovery=false;state.failed=false;
   13265             }
   13266             else {
   13267                 if (state.backtracking>0) {state.failed=true; return ;}
   13268                 MismatchedSetException mse = new MismatchedSetException(null,input);
   13269                 dbg.recognitionException(mse);
   13270                 throw mse;
   13271             }
   13272 
   13273             dbg.location(1253,39);
   13274             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumHeader7597); if (state.failed) return ;
   13275 
   13276             }
   13277 
   13278         }
   13279         catch (RecognitionException re) {
   13280             reportError(re);
   13281             recover(input,re);
   13282         }
   13283         finally {
   13284             if ( state.backtracking>0 ) { memoize(input, 104, enumHeader_StartIndex); }
   13285         }
   13286         dbg.location(1254, 5);
   13287 
   13288         }
   13289         finally {
   13290             dbg.exitRule(getGrammarFileName(), "enumHeader");
   13291             decRuleLevel();
   13292             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13293         }
   13294 
   13295         return ;
   13296     }
   13297     // $ANTLR end "enumHeader"
   13298 
   13299 
   13300     // $ANTLR start "interfaceHeader"
   13301     // src/com/google/doclava/parser/Java.g:1256:1: interfaceHeader : modifiers 'interface' IDENTIFIER ;
   13302     public final void interfaceHeader() throws RecognitionException {
   13303         int interfaceHeader_StartIndex = input.index();
   13304         try { dbg.enterRule(getGrammarFileName(), "interfaceHeader");
   13305         if ( getRuleLevel()==0 ) {dbg.commence();}
   13306         incRuleLevel();
   13307         dbg.location(1256, 1);
   13308 
   13309         try {
   13310             if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return ; }
   13311             // src/com/google/doclava/parser/Java.g:1257:5: ( modifiers 'interface' IDENTIFIER )
   13312             dbg.enterAlt(1);
   13313 
   13314             // src/com/google/doclava/parser/Java.g:1257:9: modifiers 'interface' IDENTIFIER
   13315             {
   13316             dbg.location(1257,9);
   13317             pushFollow(FOLLOW_modifiers_in_interfaceHeader7616);
   13318             modifiers();
   13319 
   13320             state._fsp--;
   13321             if (state.failed) return ;
   13322             dbg.location(1257,19);
   13323             match(input,INTERFACE,FOLLOW_INTERFACE_in_interfaceHeader7618); if (state.failed) return ;
   13324             dbg.location(1257,31);
   13325             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceHeader7620); if (state.failed) return ;
   13326 
   13327             }
   13328 
   13329         }
   13330         catch (RecognitionException re) {
   13331             reportError(re);
   13332             recover(input,re);
   13333         }
   13334         finally {
   13335             if ( state.backtracking>0 ) { memoize(input, 105, interfaceHeader_StartIndex); }
   13336         }
   13337         dbg.location(1258, 5);
   13338 
   13339         }
   13340         finally {
   13341             dbg.exitRule(getGrammarFileName(), "interfaceHeader");
   13342             decRuleLevel();
   13343             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13344         }
   13345 
   13346         return ;
   13347     }
   13348     // $ANTLR end "interfaceHeader"
   13349 
   13350 
   13351     // $ANTLR start "annotationHeader"
   13352     // src/com/google/doclava/parser/Java.g:1260:1: annotationHeader : modifiers '@' 'interface' IDENTIFIER ;
   13353     public final void annotationHeader() throws RecognitionException {
   13354         int annotationHeader_StartIndex = input.index();
   13355         try { dbg.enterRule(getGrammarFileName(), "annotationHeader");
   13356         if ( getRuleLevel()==0 ) {dbg.commence();}
   13357         incRuleLevel();
   13358         dbg.location(1260, 1);
   13359 
   13360         try {
   13361             if ( state.backtracking>0 && alreadyParsedRule(input, 106) ) { return ; }
   13362             // src/com/google/doclava/parser/Java.g:1261:5: ( modifiers '@' 'interface' IDENTIFIER )
   13363             dbg.enterAlt(1);
   13364 
   13365             // src/com/google/doclava/parser/Java.g:1261:9: modifiers '@' 'interface' IDENTIFIER
   13366             {
   13367             dbg.location(1261,9);
   13368             pushFollow(FOLLOW_modifiers_in_annotationHeader7639);
   13369             modifiers();
   13370 
   13371             state._fsp--;
   13372             if (state.failed) return ;
   13373             dbg.location(1261,19);
   13374             match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationHeader7641); if (state.failed) return ;
   13375             dbg.location(1261,23);
   13376             match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationHeader7643); if (state.failed) return ;
   13377             dbg.location(1261,35);
   13378             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationHeader7645); if (state.failed) return ;
   13379 
   13380             }
   13381 
   13382         }
   13383         catch (RecognitionException re) {
   13384             reportError(re);
   13385             recover(input,re);
   13386         }
   13387         finally {
   13388             if ( state.backtracking>0 ) { memoize(input, 106, annotationHeader_StartIndex); }
   13389         }
   13390         dbg.location(1262, 5);
   13391 
   13392         }
   13393         finally {
   13394             dbg.exitRule(getGrammarFileName(), "annotationHeader");
   13395             decRuleLevel();
   13396             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13397         }
   13398 
   13399         return ;
   13400     }
   13401     // $ANTLR end "annotationHeader"
   13402 
   13403 
   13404     // $ANTLR start "typeHeader"
   13405     // src/com/google/doclava/parser/Java.g:1264:1: typeHeader : modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER ;
   13406     public final void typeHeader() throws RecognitionException {
   13407         int typeHeader_StartIndex = input.index();
   13408         try { dbg.enterRule(getGrammarFileName(), "typeHeader");
   13409         if ( getRuleLevel()==0 ) {dbg.commence();}
   13410         incRuleLevel();
   13411         dbg.location(1264, 1);
   13412 
   13413         try {
   13414             if ( state.backtracking>0 && alreadyParsedRule(input, 107) ) { return ; }
   13415             // src/com/google/doclava/parser/Java.g:1265:5: ( modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER )
   13416             dbg.enterAlt(1);
   13417 
   13418             // src/com/google/doclava/parser/Java.g:1265:9: modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER
   13419             {
   13420             dbg.location(1265,9);
   13421             pushFollow(FOLLOW_modifiers_in_typeHeader7664);
   13422             modifiers();
   13423 
   13424             state._fsp--;
   13425             if (state.failed) return ;
   13426             dbg.location(1265,19);
   13427             // src/com/google/doclava/parser/Java.g:1265:19: ( 'class' | 'enum' | ( ( '@' )? 'interface' ) )
   13428             int alt161=3;
   13429             try { dbg.enterSubRule(161);
   13430             try { dbg.enterDecision(161, decisionCanBacktrack[161]);
   13431 
   13432             switch ( input.LA(1) ) {
   13433             case CLASS:
   13434                 {
   13435                 alt161=1;
   13436                 }
   13437                 break;
   13438             case ENUM:
   13439                 {
   13440                 alt161=2;
   13441                 }
   13442                 break;
   13443             case INTERFACE:
   13444             case MONKEYS_AT:
   13445                 {
   13446                 alt161=3;
   13447                 }
   13448                 break;
   13449             default:
   13450                 if (state.backtracking>0) {state.failed=true; return ;}
   13451                 NoViableAltException nvae =
   13452                     new NoViableAltException("", 161, 0, input);
   13453 
   13454                 dbg.recognitionException(nvae);
   13455                 throw nvae;
   13456             }
   13457 
   13458             } finally {dbg.exitDecision(161);}
   13459 
   13460             switch (alt161) {
   13461                 case 1 :
   13462                     dbg.enterAlt(1);
   13463 
   13464                     // src/com/google/doclava/parser/Java.g:1265:20: 'class'
   13465                     {
   13466                     dbg.location(1265,20);
   13467                     match(input,CLASS,FOLLOW_CLASS_in_typeHeader7667); if (state.failed) return ;
   13468 
   13469                     }
   13470                     break;
   13471                 case 2 :
   13472                     dbg.enterAlt(2);
   13473 
   13474                     // src/com/google/doclava/parser/Java.g:1265:28: 'enum'
   13475                     {
   13476                     dbg.location(1265,28);
   13477                     match(input,ENUM,FOLLOW_ENUM_in_typeHeader7669); if (state.failed) return ;
   13478 
   13479                     }
   13480                     break;
   13481                 case 3 :
   13482                     dbg.enterAlt(3);
   13483 
   13484                     // src/com/google/doclava/parser/Java.g:1265:35: ( ( '@' )? 'interface' )
   13485                     {
   13486                     dbg.location(1265,35);
   13487                     // src/com/google/doclava/parser/Java.g:1265:35: ( ( '@' )? 'interface' )
   13488                     dbg.enterAlt(1);
   13489 
   13490                     // src/com/google/doclava/parser/Java.g:1265:36: ( '@' )? 'interface'
   13491                     {
   13492                     dbg.location(1265,36);
   13493                     // src/com/google/doclava/parser/Java.g:1265:36: ( '@' )?
   13494                     int alt160=2;
   13495                     try { dbg.enterSubRule(160);
   13496                     try { dbg.enterDecision(160, decisionCanBacktrack[160]);
   13497 
   13498                     int LA160_0 = input.LA(1);
   13499 
   13500                     if ( (LA160_0==MONKEYS_AT) ) {
   13501                         alt160=1;
   13502                     }
   13503                     } finally {dbg.exitDecision(160);}
   13504 
   13505                     switch (alt160) {
   13506                         case 1 :
   13507                             dbg.enterAlt(1);
   13508 
   13509                             // src/com/google/doclava/parser/Java.g:0:0: '@'
   13510                             {
   13511                             dbg.location(1265,36);
   13512                             match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_typeHeader7672); if (state.failed) return ;
   13513 
   13514                             }
   13515                             break;
   13516 
   13517                     }
   13518                     } finally {dbg.exitSubRule(160);}
   13519 
   13520                     dbg.location(1265,42);
   13521                     match(input,INTERFACE,FOLLOW_INTERFACE_in_typeHeader7676); if (state.failed) return ;
   13522 
   13523                     }
   13524 
   13525 
   13526                     }
   13527                     break;
   13528 
   13529             }
   13530             } finally {dbg.exitSubRule(161);}
   13531 
   13532             dbg.location(1265,56);
   13533             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeHeader7680); if (state.failed) return ;
   13534 
   13535             }
   13536 
   13537         }
   13538         catch (RecognitionException re) {
   13539             reportError(re);
   13540             recover(input,re);
   13541         }
   13542         finally {
   13543             if ( state.backtracking>0 ) { memoize(input, 107, typeHeader_StartIndex); }
   13544         }
   13545         dbg.location(1266, 5);
   13546 
   13547         }
   13548         finally {
   13549             dbg.exitRule(getGrammarFileName(), "typeHeader");
   13550             decRuleLevel();
   13551             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13552         }
   13553 
   13554         return ;
   13555     }
   13556     // $ANTLR end "typeHeader"
   13557 
   13558 
   13559     // $ANTLR start "methodHeader"
   13560     // src/com/google/doclava/parser/Java.g:1268:1: methodHeader : modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' ;
   13561     public final void methodHeader() throws RecognitionException {
   13562         int methodHeader_StartIndex = input.index();
   13563         try { dbg.enterRule(getGrammarFileName(), "methodHeader");
   13564         if ( getRuleLevel()==0 ) {dbg.commence();}
   13565         incRuleLevel();
   13566         dbg.location(1268, 1);
   13567 
   13568         try {
   13569             if ( state.backtracking>0 && alreadyParsedRule(input, 108) ) { return ; }
   13570             // src/com/google/doclava/parser/Java.g:1269:5: ( modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' )
   13571             dbg.enterAlt(1);
   13572 
   13573             // src/com/google/doclava/parser/Java.g:1269:9: modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '('
   13574             {
   13575             dbg.location(1269,9);
   13576             pushFollow(FOLLOW_modifiers_in_methodHeader7699);
   13577             modifiers();
   13578 
   13579             state._fsp--;
   13580             if (state.failed) return ;
   13581             dbg.location(1269,19);
   13582             // src/com/google/doclava/parser/Java.g:1269:19: ( typeParameters )?
   13583             int alt162=2;
   13584             try { dbg.enterSubRule(162);
   13585             try { dbg.enterDecision(162, decisionCanBacktrack[162]);
   13586 
   13587             int LA162_0 = input.LA(1);
   13588 
   13589             if ( (LA162_0==LT) ) {
   13590                 alt162=1;
   13591             }
   13592             } finally {dbg.exitDecision(162);}
   13593 
   13594             switch (alt162) {
   13595                 case 1 :
   13596                     dbg.enterAlt(1);
   13597 
   13598                     // src/com/google/doclava/parser/Java.g:0:0: typeParameters
   13599                     {
   13600                     dbg.location(1269,19);
   13601                     pushFollow(FOLLOW_typeParameters_in_methodHeader7701);
   13602                     typeParameters();
   13603 
   13604                     state._fsp--;
   13605                     if (state.failed) return ;
   13606 
   13607                     }
   13608                     break;
   13609 
   13610             }
   13611             } finally {dbg.exitSubRule(162);}
   13612 
   13613             dbg.location(1269,35);
   13614             // src/com/google/doclava/parser/Java.g:1269:35: ( type | 'void' )?
   13615             int alt163=3;
   13616             try { dbg.enterSubRule(163);
   13617             try { dbg.enterDecision(163, decisionCanBacktrack[163]);
   13618 
   13619             switch ( input.LA(1) ) {
   13620                 case IDENTIFIER:
   13621                     {
   13622                     int LA163_1 = input.LA(2);
   13623 
   13624                     if ( (LA163_1==IDENTIFIER||LA163_1==LBRACKET||LA163_1==DOT||LA163_1==LT) ) {
   13625                         alt163=1;
   13626                     }
   13627                     }
   13628                     break;
   13629                 case BOOLEAN:
   13630                 case BYTE:
   13631                 case CHAR:
   13632                 case DOUBLE:
   13633                 case FLOAT:
   13634                 case INT:
   13635                 case LONG:
   13636                 case SHORT:
   13637                     {
   13638                     alt163=1;
   13639                     }
   13640                     break;
   13641                 case VOID:
   13642                     {
   13643                     alt163=2;
   13644                     }
   13645                     break;
   13646             }
   13647 
   13648             } finally {dbg.exitDecision(163);}
   13649 
   13650             switch (alt163) {
   13651                 case 1 :
   13652                     dbg.enterAlt(1);
   13653 
   13654                     // src/com/google/doclava/parser/Java.g:1269:36: type
   13655                     {
   13656                     dbg.location(1269,36);
   13657                     pushFollow(FOLLOW_type_in_methodHeader7705);
   13658                     type();
   13659 
   13660                     state._fsp--;
   13661                     if (state.failed) return ;
   13662 
   13663                     }
   13664                     break;
   13665                 case 2 :
   13666                     dbg.enterAlt(2);
   13667 
   13668                     // src/com/google/doclava/parser/Java.g:1269:41: 'void'
   13669                     {
   13670                     dbg.location(1269,41);
   13671                     match(input,VOID,FOLLOW_VOID_in_methodHeader7707); if (state.failed) return ;
   13672 
   13673                     }
   13674                     break;
   13675 
   13676             }
   13677             } finally {dbg.exitSubRule(163);}
   13678 
   13679             dbg.location(1269,50);
   13680             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodHeader7711); if (state.failed) return ;
   13681             dbg.location(1269,61);
   13682             match(input,LPAREN,FOLLOW_LPAREN_in_methodHeader7713); if (state.failed) return ;
   13683 
   13684             }
   13685 
   13686         }
   13687         catch (RecognitionException re) {
   13688             reportError(re);
   13689             recover(input,re);
   13690         }
   13691         finally {
   13692             if ( state.backtracking>0 ) { memoize(input, 108, methodHeader_StartIndex); }
   13693         }
   13694         dbg.location(1270, 5);
   13695 
   13696         }
   13697         finally {
   13698             dbg.exitRule(getGrammarFileName(), "methodHeader");
   13699             decRuleLevel();
   13700             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13701         }
   13702 
   13703         return ;
   13704     }
   13705     // $ANTLR end "methodHeader"
   13706 
   13707 
   13708     // $ANTLR start "fieldHeader"
   13709     // src/com/google/doclava/parser/Java.g:1272:1: fieldHeader : modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ;
   13710     public final void fieldHeader() throws RecognitionException {
   13711         int fieldHeader_StartIndex = input.index();
   13712         try { dbg.enterRule(getGrammarFileName(), "fieldHeader");
   13713         if ( getRuleLevel()==0 ) {dbg.commence();}
   13714         incRuleLevel();
   13715         dbg.location(1272, 1);
   13716 
   13717         try {
   13718             if ( state.backtracking>0 && alreadyParsedRule(input, 109) ) { return ; }
   13719             // src/com/google/doclava/parser/Java.g:1273:5: ( modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) )
   13720             dbg.enterAlt(1);
   13721 
   13722             // src/com/google/doclava/parser/Java.g:1273:9: modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' )
   13723             {
   13724             dbg.location(1273,9);
   13725             pushFollow(FOLLOW_modifiers_in_fieldHeader7732);
   13726             modifiers();
   13727 
   13728             state._fsp--;
   13729             if (state.failed) return ;
   13730             dbg.location(1273,19);
   13731             pushFollow(FOLLOW_type_in_fieldHeader7734);
   13732             type();
   13733 
   13734             state._fsp--;
   13735             if (state.failed) return ;
   13736             dbg.location(1273,24);
   13737             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_fieldHeader7736); if (state.failed) return ;
   13738             dbg.location(1273,35);
   13739             // src/com/google/doclava/parser/Java.g:1273:35: ( '[' ']' )*
   13740             try { dbg.enterSubRule(164);
   13741 
   13742             loop164:
   13743             do {
   13744                 int alt164=2;
   13745                 try { dbg.enterDecision(164, decisionCanBacktrack[164]);
   13746 
   13747                 int LA164_0 = input.LA(1);
   13748 
   13749                 if ( (LA164_0==LBRACKET) ) {
   13750                     alt164=1;
   13751                 }
   13752 
   13753 
   13754                 } finally {dbg.exitDecision(164);}
   13755 
   13756                 switch (alt164) {
   13757 		case 1 :
   13758 		    dbg.enterAlt(1);
   13759 
   13760 		    // src/com/google/doclava/parser/Java.g:1273:36: '[' ']'
   13761 		    {
   13762 		    dbg.location(1273,36);
   13763 		    match(input,LBRACKET,FOLLOW_LBRACKET_in_fieldHeader7739); if (state.failed) return ;
   13764 		    dbg.location(1273,39);
   13765 		    match(input,RBRACKET,FOLLOW_RBRACKET_in_fieldHeader7740); if (state.failed) return ;
   13766 
   13767 		    }
   13768 		    break;
   13769 
   13770 		default :
   13771 		    break loop164;
   13772                 }
   13773             } while (true);
   13774             } finally {dbg.exitSubRule(164);}
   13775 
   13776             dbg.location(1273,45);
   13777             if ( (input.LA(1)>=SEMI && input.LA(1)<=COMMA)||input.LA(1)==EQ ) {
   13778                 input.consume();
   13779                 state.errorRecovery=false;state.failed=false;
   13780             }
   13781             else {
   13782                 if (state.backtracking>0) {state.failed=true; return ;}
   13783                 MismatchedSetException mse = new MismatchedSetException(null,input);
   13784                 dbg.recognitionException(mse);
   13785                 throw mse;
   13786             }
   13787 
   13788 
   13789             }
   13790 
   13791         }
   13792         catch (RecognitionException re) {
   13793             reportError(re);
   13794             recover(input,re);
   13795         }
   13796         finally {
   13797             if ( state.backtracking>0 ) { memoize(input, 109, fieldHeader_StartIndex); }
   13798         }
   13799         dbg.location(1274, 5);
   13800 
   13801         }
   13802         finally {
   13803             dbg.exitRule(getGrammarFileName(), "fieldHeader");
   13804             decRuleLevel();
   13805             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13806         }
   13807 
   13808         return ;
   13809     }
   13810     // $ANTLR end "fieldHeader"
   13811 
   13812 
   13813     // $ANTLR start "localVariableHeader"
   13814     // src/com/google/doclava/parser/Java.g:1276:1: localVariableHeader : variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ;
   13815     public final void localVariableHeader() throws RecognitionException {
   13816         int localVariableHeader_StartIndex = input.index();
   13817         try { dbg.enterRule(getGrammarFileName(), "localVariableHeader");
   13818         if ( getRuleLevel()==0 ) {dbg.commence();}
   13819         incRuleLevel();
   13820         dbg.location(1276, 1);
   13821 
   13822         try {
   13823             if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return ; }
   13824             // src/com/google/doclava/parser/Java.g:1277:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) )
   13825             dbg.enterAlt(1);
   13826 
   13827             // src/com/google/doclava/parser/Java.g:1277:9: variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' )
   13828             {
   13829             dbg.location(1277,9);
   13830             pushFollow(FOLLOW_variableModifiers_in_localVariableHeader7769);
   13831             variableModifiers();
   13832 
   13833             state._fsp--;
   13834             if (state.failed) return ;
   13835             dbg.location(1277,27);
   13836             pushFollow(FOLLOW_type_in_localVariableHeader7771);
   13837             type();
   13838 
   13839             state._fsp--;
   13840             if (state.failed) return ;
   13841             dbg.location(1277,32);
   13842             match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_localVariableHeader7773); if (state.failed) return ;
   13843             dbg.location(1277,43);
   13844             // src/com/google/doclava/parser/Java.g:1277:43: ( '[' ']' )*
   13845             try { dbg.enterSubRule(165);
   13846 
   13847             loop165:
   13848             do {
   13849                 int alt165=2;
   13850                 try { dbg.enterDecision(165, decisionCanBacktrack[165]);
   13851 
   13852                 int LA165_0 = input.LA(1);
   13853 
   13854                 if ( (LA165_0==LBRACKET) ) {
   13855                     alt165=1;
   13856                 }
   13857 
   13858 
   13859                 } finally {dbg.exitDecision(165);}
   13860 
   13861                 switch (alt165) {
   13862 		case 1 :
   13863 		    dbg.enterAlt(1);
   13864 
   13865 		    // src/com/google/doclava/parser/Java.g:1277:44: '[' ']'
   13866 		    {
   13867 		    dbg.location(1277,44);
   13868 		    match(input,LBRACKET,FOLLOW_LBRACKET_in_localVariableHeader7776); if (state.failed) return ;
   13869 		    dbg.location(1277,47);
   13870 		    match(input,RBRACKET,FOLLOW_RBRACKET_in_localVariableHeader7777); if (state.failed) return ;
   13871 
   13872 		    }
   13873 		    break;
   13874 
   13875 		default :
   13876 		    break loop165;
   13877                 }
   13878             } while (true);
   13879             } finally {dbg.exitSubRule(165);}
   13880 
   13881             dbg.location(1277,53);
   13882             if ( (input.LA(1)>=SEMI && input.LA(1)<=COMMA)||input.LA(1)==EQ ) {
   13883                 input.consume();
   13884                 state.errorRecovery=false;state.failed=false;
   13885             }
   13886             else {
   13887                 if (state.backtracking>0) {state.failed=true; return ;}
   13888                 MismatchedSetException mse = new MismatchedSetException(null,input);
   13889                 dbg.recognitionException(mse);
   13890                 throw mse;
   13891             }
   13892 
   13893 
   13894             }
   13895 
   13896         }
   13897         catch (RecognitionException re) {
   13898             reportError(re);
   13899             recover(input,re);
   13900         }
   13901         finally {
   13902             if ( state.backtracking>0 ) { memoize(input, 110, localVariableHeader_StartIndex); }
   13903         }
   13904         dbg.location(1278, 5);
   13905 
   13906         }
   13907         finally {
   13908             dbg.exitRule(getGrammarFileName(), "localVariableHeader");
   13909             decRuleLevel();
   13910             if ( getRuleLevel()==0 ) {dbg.terminate();}
   13911         }
   13912 
   13913         return ;
   13914     }
   13915     // $ANTLR end "localVariableHeader"
   13916 
   13917     // $ANTLR start synpred2_Java
   13918     public final void synpred2_Java_fragment() throws RecognitionException {
   13919         // src/com/google/doclava/parser/Java.g:298:13: ( ( annotations )? packageDeclaration )
   13920         dbg.enterAlt(1);
   13921 
   13922         // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? packageDeclaration
   13923         {
   13924         dbg.location(298,13);
   13925         // src/com/google/doclava/parser/Java.g:298:13: ( annotations )?
   13926         int alt166=2;
   13927         try { dbg.enterSubRule(166);
   13928         try { dbg.enterDecision(166, decisionCanBacktrack[166]);
   13929 
   13930         int LA166_0 = input.LA(1);
   13931 
   13932         if ( (LA166_0==MONKEYS_AT) ) {
   13933             alt166=1;
   13934         }
   13935         } finally {dbg.exitDecision(166);}
   13936 
   13937         switch (alt166) {
   13938             case 1 :
   13939                 dbg.enterAlt(1);
   13940 
   13941                 // src/com/google/doclava/parser/Java.g:298:14: annotations
   13942                 {
   13943                 dbg.location(298,14);
   13944                 pushFollow(FOLLOW_annotations_in_synpred2_Java64);
   13945                 annotations();
   13946 
   13947                 state._fsp--;
   13948                 if (state.failed) return ;
   13949 
   13950                 }
   13951                 break;
   13952 
   13953         }
   13954         } finally {dbg.exitSubRule(166);}
   13955 
   13956         dbg.location(300,13);
   13957         pushFollow(FOLLOW_packageDeclaration_in_synpred2_Java93);
   13958         packageDeclaration();
   13959 
   13960         state._fsp--;
   13961         if (state.failed) return ;
   13962 
   13963         }
   13964     }
   13965     // $ANTLR end synpred2_Java
   13966 
   13967     // $ANTLR start synpred12_Java
   13968     public final void synpred12_Java_fragment() throws RecognitionException {
   13969         // src/com/google/doclava/parser/Java.g:342:10: ( classDeclaration )
   13970         dbg.enterAlt(1);
   13971 
   13972         // src/com/google/doclava/parser/Java.g:342:10: classDeclaration
   13973         {
   13974         dbg.location(342,10);
   13975         pushFollow(FOLLOW_classDeclaration_in_synpred12_Java436);
   13976         classDeclaration();
   13977 
   13978         state._fsp--;
   13979         if (state.failed) return ;
   13980 
   13981         }
   13982     }
   13983     // $ANTLR end synpred12_Java
   13984 
   13985     // $ANTLR start synpred27_Java
   13986     public final void synpred27_Java_fragment() throws RecognitionException {
   13987         // src/com/google/doclava/parser/Java.g:373:9: ( normalClassDeclaration )
   13988         dbg.enterAlt(1);
   13989 
   13990         // src/com/google/doclava/parser/Java.g:373:9: normalClassDeclaration
   13991         {
   13992         dbg.location(373,9);
   13993         pushFollow(FOLLOW_normalClassDeclaration_in_synpred27_Java659);
   13994         normalClassDeclaration();
   13995 
   13996         state._fsp--;
   13997         if (state.failed) return ;
   13998 
   13999         }
   14000     }
   14001     // $ANTLR end synpred27_Java
   14002 
   14003     // $ANTLR start synpred43_Java
   14004     public final void synpred43_Java_fragment() throws RecognitionException {
   14005         // src/com/google/doclava/parser/Java.g:461:9: ( normalInterfaceDeclaration )
   14006         dbg.enterAlt(1);
   14007 
   14008         // src/com/google/doclava/parser/Java.g:461:9: normalInterfaceDeclaration
   14009         {
   14010         dbg.location(461,9);
   14011         pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred43_Java1306);
   14012         normalInterfaceDeclaration();
   14013 
   14014         state._fsp--;
   14015         if (state.failed) return ;
   14016 
   14017         }
   14018     }
   14019     // $ANTLR end synpred43_Java
   14020 
   14021     // $ANTLR start synpred52_Java
   14022     public final void synpred52_Java_fragment() throws RecognitionException {
   14023         // src/com/google/doclava/parser/Java.g:503:10: ( fieldDeclaration )
   14024         dbg.enterAlt(1);
   14025 
   14026         // src/com/google/doclava/parser/Java.g:503:10: fieldDeclaration
   14027         {
   14028         dbg.location(503,10);
   14029         pushFollow(FOLLOW_fieldDeclaration_in_synpred52_Java1621);
   14030         fieldDeclaration();
   14031 
   14032         state._fsp--;
   14033         if (state.failed) return ;
   14034 
   14035         }
   14036     }
   14037     // $ANTLR end synpred52_Java
   14038 
   14039     // $ANTLR start synpred53_Java
   14040     public final void synpred53_Java_fragment() throws RecognitionException {
   14041         // src/com/google/doclava/parser/Java.g:504:10: ( methodDeclaration )
   14042         dbg.enterAlt(1);
   14043 
   14044         // src/com/google/doclava/parser/Java.g:504:10: methodDeclaration
   14045         {
   14046         dbg.location(504,10);
   14047         pushFollow(FOLLOW_methodDeclaration_in_synpred53_Java1632);
   14048         methodDeclaration();
   14049 
   14050         state._fsp--;
   14051         if (state.failed) return ;
   14052 
   14053         }
   14054     }
   14055     // $ANTLR end synpred53_Java
   14056 
   14057     // $ANTLR start synpred54_Java
   14058     public final void synpred54_Java_fragment() throws RecognitionException {
   14059         // src/com/google/doclava/parser/Java.g:505:10: ( classDeclaration )
   14060         dbg.enterAlt(1);
   14061 
   14062         // src/com/google/doclava/parser/Java.g:505:10: classDeclaration
   14063         {
   14064         dbg.location(505,10);
   14065         pushFollow(FOLLOW_classDeclaration_in_synpred54_Java1643);
   14066         classDeclaration();
   14067 
   14068         state._fsp--;
   14069         if (state.failed) return ;
   14070 
   14071         }
   14072     }
   14073     // $ANTLR end synpred54_Java
   14074 
   14075     // $ANTLR start synpred57_Java
   14076     public final void synpred57_Java_fragment() throws RecognitionException {
   14077         // src/com/google/doclava/parser/Java.g:521:10: ( explicitConstructorInvocation )
   14078         dbg.enterAlt(1);
   14079 
   14080         // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation
   14081         {
   14082         dbg.location(521,10);
   14083         pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred57_Java1778);
   14084         explicitConstructorInvocation();
   14085 
   14086         state._fsp--;
   14087         if (state.failed) return ;
   14088 
   14089         }
   14090     }
   14091     // $ANTLR end synpred57_Java
   14092 
   14093     // $ANTLR start synpred59_Java
   14094     public final void synpred59_Java_fragment() throws RecognitionException {
   14095         // src/com/google/doclava/parser/Java.g:513:10: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' )
   14096         dbg.enterAlt(1);
   14097 
   14098         // src/com/google/doclava/parser/Java.g:513:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}'
   14099         {
   14100         dbg.location(513,10);
   14101         pushFollow(FOLLOW_modifiers_in_synpred59_Java1691);
   14102         modifiers();
   14103 
   14104         state._fsp--;
   14105         if (state.failed) return ;
   14106         dbg.location(514,9);
   14107         // src/com/google/doclava/parser/Java.g:514:9: ( typeParameters )?
   14108         int alt169=2;
   14109         try { dbg.enterSubRule(169);
   14110         try { dbg.enterDecision(169, decisionCanBacktrack[169]);
   14111 
   14112         int LA169_0 = input.LA(1);
   14113 
   14114         if ( (LA169_0==LT) ) {
   14115             alt169=1;
   14116         }
   14117         } finally {dbg.exitDecision(169);}
   14118 
   14119         switch (alt169) {
   14120             case 1 :
   14121                 dbg.enterAlt(1);
   14122 
   14123                 // src/com/google/doclava/parser/Java.g:514:10: typeParameters
   14124                 {
   14125                 dbg.location(514,10);
   14126                 pushFollow(FOLLOW_typeParameters_in_synpred59_Java1702);
   14127                 typeParameters();
   14128 
   14129                 state._fsp--;
   14130                 if (state.failed) return ;
   14131 
   14132                 }
   14133                 break;
   14134 
   14135         }
   14136         } finally {dbg.exitSubRule(169);}
   14137 
   14138         dbg.location(516,9);
   14139         match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred59_Java1723); if (state.failed) return ;
   14140         dbg.location(517,9);
   14141         pushFollow(FOLLOW_formalParameters_in_synpred59_Java1733);
   14142         formalParameters();
   14143 
   14144         state._fsp--;
   14145         if (state.failed) return ;
   14146         dbg.location(518,9);
   14147         // src/com/google/doclava/parser/Java.g:518:9: ( 'throws' qualifiedNameList )?
   14148         int alt170=2;
   14149         try { dbg.enterSubRule(170);
   14150         try { dbg.enterDecision(170, decisionCanBacktrack[170]);
   14151 
   14152         int LA170_0 = input.LA(1);
   14153 
   14154         if ( (LA170_0==THROWS) ) {
   14155             alt170=1;
   14156         }
   14157         } finally {dbg.exitDecision(170);}
   14158 
   14159         switch (alt170) {
   14160             case 1 :
   14161                 dbg.enterAlt(1);
   14162 
   14163                 // src/com/google/doclava/parser/Java.g:518:10: 'throws' qualifiedNameList
   14164                 {
   14165                 dbg.location(518,10);
   14166                 match(input,THROWS,FOLLOW_THROWS_in_synpred59_Java1744); if (state.failed) return ;
   14167                 dbg.location(518,19);
   14168                 pushFollow(FOLLOW_qualifiedNameList_in_synpred59_Java1746);
   14169                 qualifiedNameList();
   14170 
   14171                 state._fsp--;
   14172                 if (state.failed) return ;
   14173 
   14174                 }
   14175                 break;
   14176 
   14177         }
   14178         } finally {dbg.exitSubRule(170);}
   14179 
   14180         dbg.location(520,9);
   14181         match(input,LBRACE,FOLLOW_LBRACE_in_synpred59_Java1767); if (state.failed) return ;
   14182         dbg.location(521,9);
   14183         // src/com/google/doclava/parser/Java.g:521:9: ( explicitConstructorInvocation )?
   14184         int alt171=2;
   14185         try { dbg.enterSubRule(171);
   14186         try { dbg.enterDecision(171, decisionCanBacktrack[171]);
   14187 
   14188         try {
   14189             isCyclicDecision = true;
   14190             alt171 = dfa171.predict(input);
   14191         }
   14192         catch (NoViableAltException nvae) {
   14193             dbg.recognitionException(nvae);
   14194             throw nvae;
   14195         }
   14196         } finally {dbg.exitDecision(171);}
   14197 
   14198         switch (alt171) {
   14199             case 1 :
   14200                 dbg.enterAlt(1);
   14201 
   14202                 // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation
   14203                 {
   14204                 dbg.location(521,10);
   14205                 pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred59_Java1778);
   14206                 explicitConstructorInvocation();
   14207 
   14208                 state._fsp--;
   14209                 if (state.failed) return ;
   14210 
   14211                 }
   14212                 break;
   14213 
   14214         }
   14215         } finally {dbg.exitSubRule(171);}
   14216 
   14217         dbg.location(523,9);
   14218         // src/com/google/doclava/parser/Java.g:523:9: ( blockStatement )*
   14219         try { dbg.enterSubRule(172);
   14220 
   14221         loop172:
   14222         do {
   14223             int alt172=2;
   14224             try { dbg.enterDecision(172, decisionCanBacktrack[172]);
   14225 
   14226             int LA172_0 = input.LA(1);
   14227 
   14228             if ( ((LA172_0>=IDENTIFIER && LA172_0<=NULL)||(LA172_0>=ABSTRACT && LA172_0<=BYTE)||(LA172_0>=CHAR && LA172_0<=CLASS)||LA172_0==CONTINUE||(LA172_0>=DO && LA172_0<=DOUBLE)||LA172_0==ENUM||LA172_0==FINAL||(LA172_0>=FLOAT && LA172_0<=FOR)||LA172_0==IF||(LA172_0>=INT && LA172_0<=NEW)||(LA172_0>=PRIVATE && LA172_0<=THROW)||(LA172_0>=TRANSIENT && LA172_0<=LPAREN)||LA172_0==LBRACE||LA172_0==SEMI||(LA172_0>=BANG && LA172_0<=TILDE)||(LA172_0>=PLUSPLUS && LA172_0<=SUB)||LA172_0==MONKEYS_AT||LA172_0==LT) ) {
   14229                 alt172=1;
   14230             }
   14231 
   14232 
   14233             } finally {dbg.exitDecision(172);}
   14234 
   14235             switch (alt172) {
   14236 		case 1 :
   14237 		    dbg.enterAlt(1);
   14238 
   14239 		    // src/com/google/doclava/parser/Java.g:523:10: blockStatement
   14240 		    {
   14241 		    dbg.location(523,10);
   14242 		    pushFollow(FOLLOW_blockStatement_in_synpred59_Java1800);
   14243 		    blockStatement();
   14244 
   14245 		    state._fsp--;
   14246 		    if (state.failed) return ;
   14247 
   14248 		    }
   14249 		    break;
   14250 
   14251 		default :
   14252 		    break loop172;
   14253             }
   14254         } while (true);
   14255         } finally {dbg.exitSubRule(172);}
   14256 
   14257         dbg.location(525,9);
   14258         match(input,RBRACE,FOLLOW_RBRACE_in_synpred59_Java1821); if (state.failed) return ;
   14259 
   14260         }
   14261     }
   14262     // $ANTLR end synpred59_Java
   14263 
   14264     // $ANTLR start synpred68_Java
   14265     public final void synpred68_Java_fragment() throws RecognitionException {
   14266         // src/com/google/doclava/parser/Java.g:567:9: ( interfaceFieldDeclaration )
   14267         dbg.enterAlt(1);
   14268 
   14269         // src/com/google/doclava/parser/Java.g:567:9: interfaceFieldDeclaration
   14270         {
   14271         dbg.location(567,9);
   14272         pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred68_Java2172);
   14273         interfaceFieldDeclaration();
   14274 
   14275         state._fsp--;
   14276         if (state.failed) return ;
   14277 
   14278         }
   14279     }
   14280     // $ANTLR end synpred68_Java
   14281 
   14282     // $ANTLR start synpred69_Java
   14283     public final void synpred69_Java_fragment() throws RecognitionException {
   14284         // src/com/google/doclava/parser/Java.g:568:9: ( interfaceMethodDeclaration )
   14285         dbg.enterAlt(1);
   14286 
   14287         // src/com/google/doclava/parser/Java.g:568:9: interfaceMethodDeclaration
   14288         {
   14289         dbg.location(568,9);
   14290         pushFollow(FOLLOW_interfaceMethodDeclaration_in_synpred69_Java2182);
   14291         interfaceMethodDeclaration();
   14292 
   14293         state._fsp--;
   14294         if (state.failed) return ;
   14295 
   14296         }
   14297     }
   14298     // $ANTLR end synpred69_Java
   14299 
   14300     // $ANTLR start synpred70_Java
   14301     public final void synpred70_Java_fragment() throws RecognitionException {
   14302         // src/com/google/doclava/parser/Java.g:569:9: ( interfaceDeclaration )
   14303         dbg.enterAlt(1);
   14304 
   14305         // src/com/google/doclava/parser/Java.g:569:9: interfaceDeclaration
   14306         {
   14307         dbg.location(569,9);
   14308         pushFollow(FOLLOW_interfaceDeclaration_in_synpred70_Java2192);
   14309         interfaceDeclaration();
   14310 
   14311         state._fsp--;
   14312         if (state.failed) return ;
   14313 
   14314         }
   14315     }
   14316     // $ANTLR end synpred70_Java
   14317 
   14318     // $ANTLR start synpred71_Java
   14319     public final void synpred71_Java_fragment() throws RecognitionException {
   14320         // src/com/google/doclava/parser/Java.g:570:9: ( classDeclaration )
   14321         dbg.enterAlt(1);
   14322 
   14323         // src/com/google/doclava/parser/Java.g:570:9: classDeclaration
   14324         {
   14325         dbg.location(570,9);
   14326         pushFollow(FOLLOW_classDeclaration_in_synpred71_Java2202);
   14327         classDeclaration();
   14328 
   14329         state._fsp--;
   14330         if (state.failed) return ;
   14331 
   14332         }
   14333     }
   14334     // $ANTLR end synpred71_Java
   14335 
   14336     // $ANTLR start synpred96_Java
   14337     public final void synpred96_Java_fragment() throws RecognitionException {
   14338         // src/com/google/doclava/parser/Java.g:665:9: ( ellipsisParameterDecl )
   14339         dbg.enterAlt(1);
   14340 
   14341         // src/com/google/doclava/parser/Java.g:665:9: ellipsisParameterDecl
   14342         {
   14343         dbg.location(665,9);
   14344         pushFollow(FOLLOW_ellipsisParameterDecl_in_synpred96_Java2953);
   14345         ellipsisParameterDecl();
   14346 
   14347         state._fsp--;
   14348         if (state.failed) return ;
   14349 
   14350         }
   14351     }
   14352     // $ANTLR end synpred96_Java
   14353 
   14354     // $ANTLR start synpred98_Java
   14355     public final void synpred98_Java_fragment() throws RecognitionException {
   14356         // src/com/google/doclava/parser/Java.g:666:9: ( normalParameterDecl ( ',' normalParameterDecl )* )
   14357         dbg.enterAlt(1);
   14358 
   14359         // src/com/google/doclava/parser/Java.g:666:9: normalParameterDecl ( ',' normalParameterDecl )*
   14360         {
   14361         dbg.location(666,9);
   14362         pushFollow(FOLLOW_normalParameterDecl_in_synpred98_Java2963);
   14363         normalParameterDecl();
   14364 
   14365         state._fsp--;
   14366         if (state.failed) return ;
   14367         dbg.location(667,9);
   14368         // src/com/google/doclava/parser/Java.g:667:9: ( ',' normalParameterDecl )*
   14369         try { dbg.enterSubRule(175);
   14370 
   14371         loop175:
   14372         do {
   14373             int alt175=2;
   14374             try { dbg.enterDecision(175, decisionCanBacktrack[175]);
   14375 
   14376             int LA175_0 = input.LA(1);
   14377 
   14378             if ( (LA175_0==COMMA) ) {
   14379                 alt175=1;
   14380             }
   14381 
   14382 
   14383             } finally {dbg.exitDecision(175);}
   14384 
   14385             switch (alt175) {
   14386 		case 1 :
   14387 		    dbg.enterAlt(1);
   14388 
   14389 		    // src/com/google/doclava/parser/Java.g:667:10: ',' normalParameterDecl
   14390 		    {
   14391 		    dbg.location(667,10);
   14392 		    match(input,COMMA,FOLLOW_COMMA_in_synpred98_Java2974); if (state.failed) return ;
   14393 		    dbg.location(667,14);
   14394 		    pushFollow(FOLLOW_normalParameterDecl_in_synpred98_Java2976);
   14395 		    normalParameterDecl();
   14396 
   14397 		    state._fsp--;
   14398 		    if (state.failed) return ;
   14399 
   14400 		    }
   14401 		    break;
   14402 
   14403 		default :
   14404 		    break loop175;
   14405             }
   14406         } while (true);
   14407         } finally {dbg.exitSubRule(175);}
   14408 
   14409 
   14410         }
   14411     }
   14412     // $ANTLR end synpred98_Java
   14413 
   14414     // $ANTLR start synpred99_Java
   14415     public final void synpred99_Java_fragment() throws RecognitionException {
   14416         // src/com/google/doclava/parser/Java.g:669:10: ( normalParameterDecl ',' )
   14417         dbg.enterAlt(1);
   14418 
   14419         // src/com/google/doclava/parser/Java.g:669:10: normalParameterDecl ','
   14420         {
   14421         dbg.location(669,10);
   14422         pushFollow(FOLLOW_normalParameterDecl_in_synpred99_Java2998);
   14423         normalParameterDecl();
   14424 
   14425         state._fsp--;
   14426         if (state.failed) return ;
   14427         dbg.location(670,9);
   14428         match(input,COMMA,FOLLOW_COMMA_in_synpred99_Java3008); if (state.failed) return ;
   14429 
   14430         }
   14431     }
   14432     // $ANTLR end synpred99_Java
   14433 
   14434     // $ANTLR start synpred103_Java
   14435     public final void synpred103_Java_fragment() throws RecognitionException {
   14436         // src/com/google/doclava/parser/Java.g:689:9: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' )
   14437         dbg.enterAlt(1);
   14438 
   14439         // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';'
   14440         {
   14441         dbg.location(689,9);
   14442         // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )?
   14443         int alt176=2;
   14444         try { dbg.enterSubRule(176);
   14445         try { dbg.enterDecision(176, decisionCanBacktrack[176]);
   14446 
   14447         int LA176_0 = input.LA(1);
   14448 
   14449         if ( (LA176_0==LT) ) {
   14450             alt176=1;
   14451         }
   14452         } finally {dbg.exitDecision(176);}
   14453 
   14454         switch (alt176) {
   14455             case 1 :
   14456                 dbg.enterAlt(1);
   14457 
   14458                 // src/com/google/doclava/parser/Java.g:689:10: nonWildcardTypeArguments
   14459                 {
   14460                 dbg.location(689,10);
   14461                 pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred103_Java3139);
   14462                 nonWildcardTypeArguments();
   14463 
   14464                 state._fsp--;
   14465                 if (state.failed) return ;
   14466 
   14467                 }
   14468                 break;
   14469 
   14470         }
   14471         } finally {dbg.exitSubRule(176);}
   14472 
   14473         dbg.location(691,9);
   14474         if ( input.LA(1)==SUPER||input.LA(1)==THIS ) {
   14475             input.consume();
   14476             state.errorRecovery=false;state.failed=false;
   14477         }
   14478         else {
   14479             if (state.backtracking>0) {state.failed=true; return ;}
   14480             MismatchedSetException mse = new MismatchedSetException(null,input);
   14481             dbg.recognitionException(mse);
   14482             throw mse;
   14483         }
   14484 
   14485         dbg.location(694,9);
   14486         pushFollow(FOLLOW_arguments_in_synpred103_Java3197);
   14487         arguments();
   14488 
   14489         state._fsp--;
   14490         if (state.failed) return ;
   14491         dbg.location(694,19);
   14492         match(input,SEMI,FOLLOW_SEMI_in_synpred103_Java3199); if (state.failed) return ;
   14493 
   14494         }
   14495     }
   14496     // $ANTLR end synpred103_Java
   14497 
   14498     // $ANTLR start synpred117_Java
   14499     public final void synpred117_Java_fragment() throws RecognitionException {
   14500         // src/com/google/doclava/parser/Java.g:776:9: ( annotationMethodDeclaration )
   14501         dbg.enterAlt(1);
   14502 
   14503         // src/com/google/doclava/parser/Java.g:776:9: annotationMethodDeclaration
   14504         {
   14505         dbg.location(776,9);
   14506         pushFollow(FOLLOW_annotationMethodDeclaration_in_synpred117_Java3781);
   14507         annotationMethodDeclaration();
   14508 
   14509         state._fsp--;
   14510         if (state.failed) return ;
   14511 
   14512         }
   14513     }
   14514     // $ANTLR end synpred117_Java
   14515 
   14516     // $ANTLR start synpred118_Java
   14517     public final void synpred118_Java_fragment() throws RecognitionException {
   14518         // src/com/google/doclava/parser/Java.g:777:9: ( interfaceFieldDeclaration )
   14519         dbg.enterAlt(1);
   14520 
   14521         // src/com/google/doclava/parser/Java.g:777:9: interfaceFieldDeclaration
   14522         {
   14523         dbg.location(777,9);
   14524         pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred118_Java3791);
   14525         interfaceFieldDeclaration();
   14526 
   14527         state._fsp--;
   14528         if (state.failed) return ;
   14529 
   14530         }
   14531     }
   14532     // $ANTLR end synpred118_Java
   14533 
   14534     // $ANTLR start synpred119_Java
   14535     public final void synpred119_Java_fragment() throws RecognitionException {
   14536         // src/com/google/doclava/parser/Java.g:778:9: ( normalClassDeclaration )
   14537         dbg.enterAlt(1);
   14538 
   14539         // src/com/google/doclava/parser/Java.g:778:9: normalClassDeclaration
   14540         {
   14541         dbg.location(778,9);
   14542         pushFollow(FOLLOW_normalClassDeclaration_in_synpred119_Java3801);
   14543         normalClassDeclaration();
   14544 
   14545         state._fsp--;
   14546         if (state.failed) return ;
   14547 
   14548         }
   14549     }
   14550     // $ANTLR end synpred119_Java
   14551 
   14552     // $ANTLR start synpred120_Java
   14553     public final void synpred120_Java_fragment() throws RecognitionException {
   14554         // src/com/google/doclava/parser/Java.g:779:9: ( normalInterfaceDeclaration )
   14555         dbg.enterAlt(1);
   14556 
   14557         // src/com/google/doclava/parser/Java.g:779:9: normalInterfaceDeclaration
   14558         {
   14559         dbg.location(779,9);
   14560         pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred120_Java3811);
   14561         normalInterfaceDeclaration();
   14562 
   14563         state._fsp--;
   14564         if (state.failed) return ;
   14565 
   14566         }
   14567     }
   14568     // $ANTLR end synpred120_Java
   14569 
   14570     // $ANTLR start synpred121_Java
   14571     public final void synpred121_Java_fragment() throws RecognitionException {
   14572         // src/com/google/doclava/parser/Java.g:780:9: ( enumDeclaration )
   14573         dbg.enterAlt(1);
   14574 
   14575         // src/com/google/doclava/parser/Java.g:780:9: enumDeclaration
   14576         {
   14577         dbg.location(780,9);
   14578         pushFollow(FOLLOW_enumDeclaration_in_synpred121_Java3821);
   14579         enumDeclaration();
   14580 
   14581         state._fsp--;
   14582         if (state.failed) return ;
   14583 
   14584         }
   14585     }
   14586     // $ANTLR end synpred121_Java
   14587 
   14588     // $ANTLR start synpred122_Java
   14589     public final void synpred122_Java_fragment() throws RecognitionException {
   14590         // src/com/google/doclava/parser/Java.g:781:9: ( annotationTypeDeclaration )
   14591         dbg.enterAlt(1);
   14592 
   14593         // src/com/google/doclava/parser/Java.g:781:9: annotationTypeDeclaration
   14594         {
   14595         dbg.location(781,9);
   14596         pushFollow(FOLLOW_annotationTypeDeclaration_in_synpred122_Java3831);
   14597         annotationTypeDeclaration();
   14598 
   14599         state._fsp--;
   14600         if (state.failed) return ;
   14601 
   14602         }
   14603     }
   14604     // $ANTLR end synpred122_Java
   14605 
   14606     // $ANTLR start synpred125_Java
   14607     public final void synpred125_Java_fragment() throws RecognitionException {
   14608         // src/com/google/doclava/parser/Java.g:824:9: ( localVariableDeclarationStatement )
   14609         dbg.enterAlt(1);
   14610 
   14611         // src/com/google/doclava/parser/Java.g:824:9: localVariableDeclarationStatement
   14612         {
   14613         dbg.location(824,9);
   14614         pushFollow(FOLLOW_localVariableDeclarationStatement_in_synpred125_Java3986);
   14615         localVariableDeclarationStatement();
   14616 
   14617         state._fsp--;
   14618         if (state.failed) return ;
   14619 
   14620         }
   14621     }
   14622     // $ANTLR end synpred125_Java
   14623 
   14624     // $ANTLR start synpred126_Java
   14625     public final void synpred126_Java_fragment() throws RecognitionException {
   14626         // src/com/google/doclava/parser/Java.g:825:9: ( classOrInterfaceDeclaration )
   14627         dbg.enterAlt(1);
   14628 
   14629         // src/com/google/doclava/parser/Java.g:825:9: classOrInterfaceDeclaration
   14630         {
   14631         dbg.location(825,9);
   14632         pushFollow(FOLLOW_classOrInterfaceDeclaration_in_synpred126_Java3996);
   14633         classOrInterfaceDeclaration();
   14634 
   14635         state._fsp--;
   14636         if (state.failed) return ;
   14637 
   14638         }
   14639     }
   14640     // $ANTLR end synpred126_Java
   14641 
   14642     // $ANTLR start synpred130_Java
   14643     public final void synpred130_Java_fragment() throws RecognitionException {
   14644         // src/com/google/doclava/parser/Java.g:845:9: ( ( 'assert' ) expression ( ':' expression )? ';' )
   14645         dbg.enterAlt(1);
   14646 
   14647         // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) expression ( ':' expression )? ';'
   14648         {
   14649         dbg.location(845,9);
   14650         // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' )
   14651         dbg.enterAlt(1);
   14652 
   14653         // src/com/google/doclava/parser/Java.g:845:10: 'assert'
   14654         {
   14655         dbg.location(845,10);
   14656         match(input,ASSERT,FOLLOW_ASSERT_in_synpred130_Java4122); if (state.failed) return ;
   14657 
   14658         }
   14659 
   14660         dbg.location(847,9);
   14661         pushFollow(FOLLOW_expression_in_synpred130_Java4142);
   14662         expression();
   14663 
   14664         state._fsp--;
   14665         if (state.failed) return ;
   14666         dbg.location(847,20);
   14667         // src/com/google/doclava/parser/Java.g:847:20: ( ':' expression )?
   14668         int alt179=2;
   14669         try { dbg.enterSubRule(179);
   14670         try { dbg.enterDecision(179, decisionCanBacktrack[179]);
   14671 
   14672         int LA179_0 = input.LA(1);
   14673 
   14674         if ( (LA179_0==COLON) ) {
   14675             alt179=1;
   14676         }
   14677         } finally {dbg.exitDecision(179);}
   14678 
   14679         switch (alt179) {
   14680             case 1 :
   14681                 dbg.enterAlt(1);
   14682 
   14683                 // src/com/google/doclava/parser/Java.g:847:21: ':' expression
   14684                 {
   14685                 dbg.location(847,21);
   14686                 match(input,COLON,FOLLOW_COLON_in_synpred130_Java4145); if (state.failed) return ;
   14687                 dbg.location(847,25);
   14688                 pushFollow(FOLLOW_expression_in_synpred130_Java4147);
   14689                 expression();
   14690 
   14691                 state._fsp--;
   14692                 if (state.failed) return ;
   14693 
   14694                 }
   14695                 break;
   14696 
   14697         }
   14698         } finally {dbg.exitSubRule(179);}
   14699 
   14700         dbg.location(847,38);
   14701         match(input,SEMI,FOLLOW_SEMI_in_synpred130_Java4151); if (state.failed) return ;
   14702 
   14703         }
   14704     }
   14705     // $ANTLR end synpred130_Java
   14706 
   14707     // $ANTLR start synpred132_Java
   14708     public final void synpred132_Java_fragment() throws RecognitionException {
   14709         // src/com/google/doclava/parser/Java.g:848:9: ( 'assert' expression ( ':' expression )? ';' )
   14710         dbg.enterAlt(1);
   14711 
   14712         // src/com/google/doclava/parser/Java.g:848:9: 'assert' expression ( ':' expression )? ';'
   14713         {
   14714         dbg.location(848,9);
   14715         match(input,ASSERT,FOLLOW_ASSERT_in_synpred132_Java4161); if (state.failed) return ;
   14716         dbg.location(848,19);
   14717         pushFollow(FOLLOW_expression_in_synpred132_Java4164);
   14718         expression();
   14719 
   14720         state._fsp--;
   14721         if (state.failed) return ;
   14722         dbg.location(848,30);
   14723         // src/com/google/doclava/parser/Java.g:848:30: ( ':' expression )?
   14724         int alt180=2;
   14725         try { dbg.enterSubRule(180);
   14726         try { dbg.enterDecision(180, decisionCanBacktrack[180]);
   14727 
   14728         int LA180_0 = input.LA(1);
   14729 
   14730         if ( (LA180_0==COLON) ) {
   14731             alt180=1;
   14732         }
   14733         } finally {dbg.exitDecision(180);}
   14734 
   14735         switch (alt180) {
   14736             case 1 :
   14737                 dbg.enterAlt(1);
   14738 
   14739                 // src/com/google/doclava/parser/Java.g:848:31: ':' expression
   14740                 {
   14741                 dbg.location(848,31);
   14742                 match(input,COLON,FOLLOW_COLON_in_synpred132_Java4167); if (state.failed) return ;
   14743                 dbg.location(848,35);
   14744                 pushFollow(FOLLOW_expression_in_synpred132_Java4169);
   14745                 expression();
   14746 
   14747                 state._fsp--;
   14748                 if (state.failed) return ;
   14749 
   14750                 }
   14751                 break;
   14752 
   14753         }
   14754         } finally {dbg.exitSubRule(180);}
   14755 
   14756         dbg.location(848,48);
   14757         match(input,SEMI,FOLLOW_SEMI_in_synpred132_Java4173); if (state.failed) return ;
   14758 
   14759         }
   14760     }
   14761     // $ANTLR end synpred132_Java
   14762 
   14763     // $ANTLR start synpred133_Java
   14764     public final void synpred133_Java_fragment() throws RecognitionException {
   14765         // src/com/google/doclava/parser/Java.g:849:39: ( 'else' statement )
   14766         dbg.enterAlt(1);
   14767 
   14768         // src/com/google/doclava/parser/Java.g:849:39: 'else' statement
   14769         {
   14770         dbg.location(849,39);
   14771         match(input,ELSE,FOLLOW_ELSE_in_synpred133_Java4190); if (state.failed) return ;
   14772         dbg.location(849,46);
   14773         pushFollow(FOLLOW_statement_in_synpred133_Java4192);
   14774         statement();
   14775 
   14776         state._fsp--;
   14777         if (state.failed) return ;
   14778 
   14779         }
   14780     }
   14781     // $ANTLR end synpred133_Java
   14782 
   14783     // $ANTLR start synpred148_Java
   14784     public final void synpred148_Java_fragment() throws RecognitionException {
   14785         // src/com/google/doclava/parser/Java.g:864:9: ( expression ';' )
   14786         dbg.enterAlt(1);
   14787 
   14788         // src/com/google/doclava/parser/Java.g:864:9: expression ';'
   14789         {
   14790         dbg.location(864,9);
   14791         pushFollow(FOLLOW_expression_in_synpred148_Java4404);
   14792         expression();
   14793 
   14794         state._fsp--;
   14795         if (state.failed) return ;
   14796         dbg.location(864,21);
   14797         match(input,SEMI,FOLLOW_SEMI_in_synpred148_Java4407); if (state.failed) return ;
   14798 
   14799         }
   14800     }
   14801     // $ANTLR end synpred148_Java
   14802 
   14803     // $ANTLR start synpred149_Java
   14804     public final void synpred149_Java_fragment() throws RecognitionException {
   14805         // src/com/google/doclava/parser/Java.g:865:9: ( IDENTIFIER ':' statement )
   14806         dbg.enterAlt(1);
   14807 
   14808         // src/com/google/doclava/parser/Java.g:865:9: IDENTIFIER ':' statement
   14809         {
   14810         dbg.location(865,9);
   14811         match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred149_Java4417); if (state.failed) return ;
   14812         dbg.location(865,20);
   14813         match(input,COLON,FOLLOW_COLON_in_synpred149_Java4419); if (state.failed) return ;
   14814         dbg.location(865,24);
   14815         pushFollow(FOLLOW_statement_in_synpred149_Java4421);
   14816         statement();
   14817 
   14818         state._fsp--;
   14819         if (state.failed) return ;
   14820 
   14821         }
   14822     }
   14823     // $ANTLR end synpred149_Java
   14824 
   14825     // $ANTLR start synpred153_Java
   14826     public final void synpred153_Java_fragment() throws RecognitionException {
   14827         // src/com/google/doclava/parser/Java.g:889:13: ( catches 'finally' block )
   14828         dbg.enterAlt(1);
   14829 
   14830         // src/com/google/doclava/parser/Java.g:889:13: catches 'finally' block
   14831         {
   14832         dbg.location(889,13);
   14833         pushFollow(FOLLOW_catches_in_synpred153_Java4573);
   14834         catches();
   14835 
   14836         state._fsp--;
   14837         if (state.failed) return ;
   14838         dbg.location(889,21);
   14839         match(input,FINALLY,FOLLOW_FINALLY_in_synpred153_Java4575); if (state.failed) return ;
   14840         dbg.location(889,31);
   14841         pushFollow(FOLLOW_block_in_synpred153_Java4577);
   14842         block();
   14843 
   14844         state._fsp--;
   14845         if (state.failed) return ;
   14846 
   14847         }
   14848     }
   14849     // $ANTLR end synpred153_Java
   14850 
   14851     // $ANTLR start synpred154_Java
   14852     public final void synpred154_Java_fragment() throws RecognitionException {
   14853         // src/com/google/doclava/parser/Java.g:890:13: ( catches )
   14854         dbg.enterAlt(1);
   14855 
   14856         // src/com/google/doclava/parser/Java.g:890:13: catches
   14857         {
   14858         dbg.location(890,13);
   14859         pushFollow(FOLLOW_catches_in_synpred154_Java4591);
   14860         catches();
   14861 
   14862         state._fsp--;
   14863         if (state.failed) return ;
   14864 
   14865         }
   14866     }
   14867     // $ANTLR end synpred154_Java
   14868 
   14869     // $ANTLR start synpred157_Java
   14870     public final void synpred157_Java_fragment() throws RecognitionException {
   14871         // src/com/google/doclava/parser/Java.g:915:9: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement )
   14872         dbg.enterAlt(1);
   14873 
   14874         // src/com/google/doclava/parser/Java.g:915:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement
   14875         {
   14876         dbg.location(915,9);
   14877         match(input,FOR,FOLLOW_FOR_in_synpred157_Java4775); if (state.failed) return ;
   14878         dbg.location(915,15);
   14879         match(input,LPAREN,FOLLOW_LPAREN_in_synpred157_Java4777); if (state.failed) return ;
   14880         dbg.location(915,19);
   14881         pushFollow(FOLLOW_variableModifiers_in_synpred157_Java4779);
   14882         variableModifiers();
   14883 
   14884         state._fsp--;
   14885         if (state.failed) return ;
   14886         dbg.location(915,37);
   14887         pushFollow(FOLLOW_type_in_synpred157_Java4781);
   14888         type();
   14889 
   14890         state._fsp--;
   14891         if (state.failed) return ;
   14892         dbg.location(915,42);
   14893         match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred157_Java4783); if (state.failed) return ;
   14894         dbg.location(915,53);
   14895         match(input,COLON,FOLLOW_COLON_in_synpred157_Java4785); if (state.failed) return ;
   14896         dbg.location(916,9);
   14897         pushFollow(FOLLOW_expression_in_synpred157_Java4795);
   14898         expression();
   14899 
   14900         state._fsp--;
   14901         if (state.failed) return ;
   14902         dbg.location(916,20);
   14903         match(input,RPAREN,FOLLOW_RPAREN_in_synpred157_Java4797); if (state.failed) return ;
   14904         dbg.location(916,24);
   14905         pushFollow(FOLLOW_statement_in_synpred157_Java4799);
   14906         statement();
   14907 
   14908         state._fsp--;
   14909         if (state.failed) return ;
   14910 
   14911         }
   14912     }
   14913     // $ANTLR end synpred157_Java
   14914 
   14915     // $ANTLR start synpred161_Java
   14916     public final void synpred161_Java_fragment() throws RecognitionException {
   14917         // src/com/google/doclava/parser/Java.g:929:9: ( localVariableDeclaration )
   14918         dbg.enterAlt(1);
   14919 
   14920         // src/com/google/doclava/parser/Java.g:929:9: localVariableDeclaration
   14921         {
   14922         dbg.location(929,9);
   14923         pushFollow(FOLLOW_localVariableDeclaration_in_synpred161_Java4962);
   14924         localVariableDeclaration();
   14925 
   14926         state._fsp--;
   14927         if (state.failed) return ;
   14928 
   14929         }
   14930     }
   14931     // $ANTLR end synpred161_Java
   14932 
   14933     // $ANTLR start synpred202_Java
   14934     public final void synpred202_Java_fragment() throws RecognitionException {
   14935         // src/com/google/doclava/parser/Java.g:1083:9: ( castExpression )
   14936         dbg.enterAlt(1);
   14937 
   14938         // src/com/google/doclava/parser/Java.g:1083:9: castExpression
   14939         {
   14940         dbg.location(1083,9);
   14941         pushFollow(FOLLOW_castExpression_in_synpred202_Java6178);
   14942         castExpression();
   14943 
   14944         state._fsp--;
   14945         if (state.failed) return ;
   14946 
   14947         }
   14948     }
   14949     // $ANTLR end synpred202_Java
   14950 
   14951     // $ANTLR start synpred206_Java
   14952     public final void synpred206_Java_fragment() throws RecognitionException {
   14953         // src/com/google/doclava/parser/Java.g:1093:9: ( '(' primitiveType ')' unaryExpression )
   14954         dbg.enterAlt(1);
   14955 
   14956         // src/com/google/doclava/parser/Java.g:1093:9: '(' primitiveType ')' unaryExpression
   14957         {
   14958         dbg.location(1093,9);
   14959         match(input,LPAREN,FOLLOW_LPAREN_in_synpred206_Java6268); if (state.failed) return ;
   14960         dbg.location(1093,13);
   14961         pushFollow(FOLLOW_primitiveType_in_synpred206_Java6270);
   14962         primitiveType();
   14963 
   14964         state._fsp--;
   14965         if (state.failed) return ;
   14966         dbg.location(1093,27);
   14967         match(input,RPAREN,FOLLOW_RPAREN_in_synpred206_Java6272); if (state.failed) return ;
   14968         dbg.location(1093,31);
   14969         pushFollow(FOLLOW_unaryExpression_in_synpred206_Java6274);
   14970         unaryExpression();
   14971 
   14972         state._fsp--;
   14973         if (state.failed) return ;
   14974 
   14975         }
   14976     }
   14977     // $ANTLR end synpred206_Java
   14978 
   14979     // $ANTLR start synpred208_Java
   14980     public final void synpred208_Java_fragment() throws RecognitionException {
   14981         // src/com/google/doclava/parser/Java.g:1103:10: ( '.' IDENTIFIER )
   14982         dbg.enterAlt(1);
   14983 
   14984         // src/com/google/doclava/parser/Java.g:1103:10: '.' IDENTIFIER
   14985         {
   14986         dbg.location(1103,10);
   14987         match(input,DOT,FOLLOW_DOT_in_synpred208_Java6332); if (state.failed) return ;
   14988         dbg.location(1103,14);
   14989         match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred208_Java6334); if (state.failed) return ;
   14990 
   14991         }
   14992     }
   14993     // $ANTLR end synpred208_Java
   14994 
   14995     // $ANTLR start synpred209_Java
   14996     public final void synpred209_Java_fragment() throws RecognitionException {
   14997         // src/com/google/doclava/parser/Java.g:1105:10: ( identifierSuffix )
   14998         dbg.enterAlt(1);
   14999 
   15000         // src/com/google/doclava/parser/Java.g:1105:10: identifierSuffix
   15001         {
   15002         dbg.location(1105,10);
   15003         pushFollow(FOLLOW_identifierSuffix_in_synpred209_Java6356);
   15004         identifierSuffix();
   15005 
   15006         state._fsp--;
   15007         if (state.failed) return ;
   15008 
   15009         }
   15010     }
   15011     // $ANTLR end synpred209_Java
   15012 
   15013     // $ANTLR start synpred211_Java
   15014     public final void synpred211_Java_fragment() throws RecognitionException {
   15015         // src/com/google/doclava/parser/Java.g:1108:10: ( '.' IDENTIFIER )
   15016         dbg.enterAlt(1);
   15017 
   15018         // src/com/google/doclava/parser/Java.g:1108:10: '.' IDENTIFIER
   15019         {
   15020         dbg.location(1108,10);
   15021         match(input,DOT,FOLLOW_DOT_in_synpred211_Java6388); if (state.failed) return ;
   15022         dbg.location(1108,14);
   15023         match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred211_Java6390); if (state.failed) return ;
   15024 
   15025         }
   15026     }
   15027     // $ANTLR end synpred211_Java
   15028 
   15029     // $ANTLR start synpred212_Java
   15030     public final void synpred212_Java_fragment() throws RecognitionException {
   15031         // src/com/google/doclava/parser/Java.g:1110:10: ( identifierSuffix )
   15032         dbg.enterAlt(1);
   15033 
   15034         // src/com/google/doclava/parser/Java.g:1110:10: identifierSuffix
   15035         {
   15036         dbg.location(1110,10);
   15037         pushFollow(FOLLOW_identifierSuffix_in_synpred212_Java6412);
   15038         identifierSuffix();
   15039 
   15040         state._fsp--;
   15041         if (state.failed) return ;
   15042 
   15043         }
   15044     }
   15045     // $ANTLR end synpred212_Java
   15046 
   15047     // $ANTLR start synpred224_Java
   15048     public final void synpred224_Java_fragment() throws RecognitionException {
   15049         // src/com/google/doclava/parser/Java.g:1138:10: ( '[' expression ']' )
   15050         dbg.enterAlt(1);
   15051 
   15052         // src/com/google/doclava/parser/Java.g:1138:10: '[' expression ']'
   15053         {
   15054         dbg.location(1138,10);
   15055         match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred224_Java6656); if (state.failed) return ;
   15056         dbg.location(1138,14);
   15057         pushFollow(FOLLOW_expression_in_synpred224_Java6658);
   15058         expression();
   15059 
   15060         state._fsp--;
   15061         if (state.failed) return ;
   15062         dbg.location(1138,25);
   15063         match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred224_Java6660); if (state.failed) return ;
   15064 
   15065         }
   15066     }
   15067     // $ANTLR end synpred224_Java
   15068 
   15069     // $ANTLR start synpred236_Java
   15070     public final void synpred236_Java_fragment() throws RecognitionException {
   15071         // src/com/google/doclava/parser/Java.g:1161:9: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest )
   15072         dbg.enterAlt(1);
   15073 
   15074         // src/com/google/doclava/parser/Java.g:1161:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest
   15075         {
   15076         dbg.location(1161,9);
   15077         match(input,NEW,FOLLOW_NEW_in_synpred236_Java6866); if (state.failed) return ;
   15078         dbg.location(1161,15);
   15079         pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred236_Java6868);
   15080         nonWildcardTypeArguments();
   15081 
   15082         state._fsp--;
   15083         if (state.failed) return ;
   15084         dbg.location(1161,40);
   15085         pushFollow(FOLLOW_classOrInterfaceType_in_synpred236_Java6870);
   15086         classOrInterfaceType();
   15087 
   15088         state._fsp--;
   15089         if (state.failed) return ;
   15090         dbg.location(1161,61);
   15091         pushFollow(FOLLOW_classCreatorRest_in_synpred236_Java6872);
   15092         classCreatorRest();
   15093 
   15094         state._fsp--;
   15095         if (state.failed) return ;
   15096 
   15097         }
   15098     }
   15099     // $ANTLR end synpred236_Java
   15100 
   15101     // $ANTLR start synpred237_Java
   15102     public final void synpred237_Java_fragment() throws RecognitionException {
   15103         // src/com/google/doclava/parser/Java.g:1162:9: ( 'new' classOrInterfaceType classCreatorRest )
   15104         dbg.enterAlt(1);
   15105 
   15106         // src/com/google/doclava/parser/Java.g:1162:9: 'new' classOrInterfaceType classCreatorRest
   15107         {
   15108         dbg.location(1162,9);
   15109         match(input,NEW,FOLLOW_NEW_in_synpred237_Java6882); if (state.failed) return ;
   15110         dbg.location(1162,15);
   15111         pushFollow(FOLLOW_classOrInterfaceType_in_synpred237_Java6884);
   15112         classOrInterfaceType();
   15113 
   15114         state._fsp--;
   15115         if (state.failed) return ;
   15116         dbg.location(1162,36);
   15117         pushFollow(FOLLOW_classCreatorRest_in_synpred237_Java6886);
   15118         classCreatorRest();
   15119 
   15120         state._fsp--;
   15121         if (state.failed) return ;
   15122 
   15123         }
   15124     }
   15125     // $ANTLR end synpred237_Java
   15126 
   15127     // $ANTLR start synpred239_Java
   15128     public final void synpred239_Java_fragment() throws RecognitionException {
   15129         // src/com/google/doclava/parser/Java.g:1167:9: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer )
   15130         dbg.enterAlt(1);
   15131 
   15132         // src/com/google/doclava/parser/Java.g:1167:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer
   15133         {
   15134         dbg.location(1167,9);
   15135         match(input,NEW,FOLLOW_NEW_in_synpred239_Java6915); if (state.failed) return ;
   15136         dbg.location(1167,15);
   15137         pushFollow(FOLLOW_createdName_in_synpred239_Java6917);
   15138         createdName();
   15139 
   15140         state._fsp--;
   15141         if (state.failed) return ;
   15142         dbg.location(1168,9);
   15143         match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred239_Java6927); if (state.failed) return ;
   15144         dbg.location(1168,13);
   15145         match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred239_Java6929); if (state.failed) return ;
   15146         dbg.location(1169,9);
   15147         // src/com/google/doclava/parser/Java.g:1169:9: ( '[' ']' )*
   15148         try { dbg.enterSubRule(193);
   15149 
   15150         loop193:
   15151         do {
   15152             int alt193=2;
   15153             try { dbg.enterDecision(193, decisionCanBacktrack[193]);
   15154 
   15155             int LA193_0 = input.LA(1);
   15156 
   15157             if ( (LA193_0==LBRACKET) ) {
   15158                 alt193=1;
   15159             }
   15160 
   15161 
   15162             } finally {dbg.exitDecision(193);}
   15163 
   15164             switch (alt193) {
   15165 		case 1 :
   15166 		    dbg.enterAlt(1);
   15167 
   15168 		    // src/com/google/doclava/parser/Java.g:1169:10: '[' ']'
   15169 		    {
   15170 		    dbg.location(1169,10);
   15171 		    match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred239_Java6940); if (state.failed) return ;
   15172 		    dbg.location(1169,14);
   15173 		    match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred239_Java6942); if (state.failed) return ;
   15174 
   15175 		    }
   15176 		    break;
   15177 
   15178 		default :
   15179 		    break loop193;
   15180             }
   15181         } while (true);
   15182         } finally {dbg.exitSubRule(193);}
   15183 
   15184         dbg.location(1171,9);
   15185         pushFollow(FOLLOW_arrayInitializer_in_synpred239_Java6963);
   15186         arrayInitializer();
   15187 
   15188         state._fsp--;
   15189         if (state.failed) return ;
   15190 
   15191         }
   15192     }
   15193     // $ANTLR end synpred239_Java
   15194 
   15195     // $ANTLR start synpred240_Java
   15196     public final void synpred240_Java_fragment() throws RecognitionException {
   15197         // src/com/google/doclava/parser/Java.g:1176:13: ( '[' expression ']' )
   15198         dbg.enterAlt(1);
   15199 
   15200         // src/com/google/doclava/parser/Java.g:1176:13: '[' expression ']'
   15201         {
   15202         dbg.location(1176,13);
   15203         match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred240_Java7012); if (state.failed) return ;
   15204         dbg.location(1176,17);
   15205         pushFollow(FOLLOW_expression_in_synpred240_Java7014);
   15206         expression();
   15207 
   15208         state._fsp--;
   15209         if (state.failed) return ;
   15210         dbg.location(1177,13);
   15211         match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred240_Java7028); if (state.failed) return ;
   15212 
   15213         }
   15214     }
   15215     // $ANTLR end synpred240_Java
   15216 
   15217     // Delegated rules
   15218 
   15219     public final boolean synpred43_Java() {
   15220         state.backtracking++;
   15221         dbg.beginBacktrack(state.backtracking);
   15222         int start = input.mark();
   15223         try {
   15224             synpred43_Java_fragment(); // can never throw exception
   15225         } catch (RecognitionException re) {
   15226             System.err.println("impossible: "+re);
   15227         }
   15228         boolean success = !state.failed;
   15229         input.rewind(start);
   15230         dbg.endBacktrack(state.backtracking, success);
   15231         state.backtracking--;
   15232         state.failed=false;
   15233         return success;
   15234     }
   15235     public final boolean synpred98_Java() {
   15236         state.backtracking++;
   15237         dbg.beginBacktrack(state.backtracking);
   15238         int start = input.mark();
   15239         try {
   15240             synpred98_Java_fragment(); // can never throw exception
   15241         } catch (RecognitionException re) {
   15242             System.err.println("impossible: "+re);
   15243         }
   15244         boolean success = !state.failed;
   15245         input.rewind(start);
   15246         dbg.endBacktrack(state.backtracking, success);
   15247         state.backtracking--;
   15248         state.failed=false;
   15249         return success;
   15250     }
   15251     public final boolean synpred157_Java() {
   15252         state.backtracking++;
   15253         dbg.beginBacktrack(state.backtracking);
   15254         int start = input.mark();
   15255         try {
   15256             synpred157_Java_fragment(); // can never throw exception
   15257         } catch (RecognitionException re) {
   15258             System.err.println("impossible: "+re);
   15259         }
   15260         boolean success = !state.failed;
   15261         input.rewind(start);
   15262         dbg.endBacktrack(state.backtracking, success);
   15263         state.backtracking--;
   15264         state.failed=false;
   15265         return success;
   15266     }
   15267     public final boolean synpred224_Java() {
   15268         state.backtracking++;
   15269         dbg.beginBacktrack(state.backtracking);
   15270         int start = input.mark();
   15271         try {
   15272             synpred224_Java_fragment(); // can never throw exception
   15273         } catch (RecognitionException re) {
   15274             System.err.println("impossible: "+re);
   15275         }
   15276         boolean success = !state.failed;
   15277         input.rewind(start);
   15278         dbg.endBacktrack(state.backtracking, success);
   15279         state.backtracking--;
   15280         state.failed=false;
   15281         return success;
   15282     }
   15283     public final boolean synpred211_Java() {
   15284         state.backtracking++;
   15285         dbg.beginBacktrack(state.backtracking);
   15286         int start = input.mark();
   15287         try {
   15288             synpred211_Java_fragment(); // can never throw exception
   15289         } catch (RecognitionException re) {
   15290             System.err.println("impossible: "+re);
   15291         }
   15292         boolean success = !state.failed;
   15293         input.rewind(start);
   15294         dbg.endBacktrack(state.backtracking, success);
   15295         state.backtracking--;
   15296         state.failed=false;
   15297         return success;
   15298     }
   15299     public final boolean synpred121_Java() {
   15300         state.backtracking++;
   15301         dbg.beginBacktrack(state.backtracking);
   15302         int start = input.mark();
   15303         try {
   15304             synpred121_Java_fragment(); // can never throw exception
   15305         } catch (RecognitionException re) {
   15306             System.err.println("impossible: "+re);
   15307         }
   15308         boolean success = !state.failed;
   15309         input.rewind(start);
   15310         dbg.endBacktrack(state.backtracking, success);
   15311         state.backtracking--;
   15312         state.failed=false;
   15313         return success;
   15314     }
   15315     public final boolean synpred239_Java() {
   15316         state.backtracking++;
   15317         dbg.beginBacktrack(state.backtracking);
   15318         int start = input.mark();
   15319         try {
   15320             synpred239_Java_fragment(); // can never throw exception
   15321         } catch (RecognitionException re) {
   15322             System.err.println("impossible: "+re);
   15323         }
   15324         boolean success = !state.failed;
   15325         input.rewind(start);
   15326         dbg.endBacktrack(state.backtracking, success);
   15327         state.backtracking--;
   15328         state.failed=false;
   15329         return success;
   15330     }
   15331     public final boolean synpred69_Java() {
   15332         state.backtracking++;
   15333         dbg.beginBacktrack(state.backtracking);
   15334         int start = input.mark();
   15335         try {
   15336             synpred69_Java_fragment(); // can never throw exception
   15337         } catch (RecognitionException re) {
   15338             System.err.println("impossible: "+re);
   15339         }
   15340         boolean success = !state.failed;
   15341         input.rewind(start);
   15342         dbg.endBacktrack(state.backtracking, success);
   15343         state.backtracking--;
   15344         state.failed=false;
   15345         return success;
   15346     }
   15347     public final boolean synpred202_Java() {
   15348         state.backtracking++;
   15349         dbg.beginBacktrack(state.backtracking);
   15350         int start = input.mark();
   15351         try {
   15352             synpred202_Java_fragment(); // can never throw exception
   15353         } catch (RecognitionException re) {
   15354             System.err.println("impossible: "+re);
   15355         }
   15356         boolean success = !state.failed;
   15357         input.rewind(start);
   15358         dbg.endBacktrack(state.backtracking, success);
   15359         state.backtracking--;
   15360         state.failed=false;
   15361         return success;
   15362     }
   15363     public final boolean synpred154_Java() {
   15364         state.backtracking++;
   15365         dbg.beginBacktrack(state.backtracking);
   15366         int start = input.mark();
   15367         try {
   15368             synpred154_Java_fragment(); // can never throw exception
   15369         } catch (RecognitionException re) {
   15370             System.err.println("impossible: "+re);
   15371         }
   15372         boolean success = !state.failed;
   15373         input.rewind(start);
   15374         dbg.endBacktrack(state.backtracking, success);
   15375         state.backtracking--;
   15376         state.failed=false;
   15377         return success;
   15378     }
   15379     public final boolean synpred71_Java() {
   15380         state.backtracking++;
   15381         dbg.beginBacktrack(state.backtracking);
   15382         int start = input.mark();
   15383         try {
   15384             synpred71_Java_fragment(); // can never throw exception
   15385         } catch (RecognitionException re) {
   15386             System.err.println("impossible: "+re);
   15387         }
   15388         boolean success = !state.failed;
   15389         input.rewind(start);
   15390         dbg.endBacktrack(state.backtracking, success);
   15391         state.backtracking--;
   15392         state.failed=false;
   15393         return success;
   15394     }
   15395     public final boolean synpred133_Java() {
   15396         state.backtracking++;
   15397         dbg.beginBacktrack(state.backtracking);
   15398         int start = input.mark();
   15399         try {
   15400             synpred133_Java_fragment(); // can never throw exception
   15401         } catch (RecognitionException re) {
   15402             System.err.println("impossible: "+re);
   15403         }
   15404         boolean success = !state.failed;
   15405         input.rewind(start);
   15406         dbg.endBacktrack(state.backtracking, success);
   15407         state.backtracking--;
   15408         state.failed=false;
   15409         return success;
   15410     }
   15411     public final boolean synpred125_Java() {
   15412         state.backtracking++;
   15413         dbg.beginBacktrack(state.backtracking);
   15414         int start = input.mark();
   15415         try {
   15416             synpred125_Java_fragment(); // can never throw exception
   15417         } catch (RecognitionException re) {
   15418             System.err.println("impossible: "+re);
   15419         }
   15420         boolean success = !state.failed;
   15421         input.rewind(start);
   15422         dbg.endBacktrack(state.backtracking, success);
   15423         state.backtracking--;
   15424         state.failed=false;
   15425         return success;
   15426     }
   15427     public final boolean synpred132_Java() {
   15428         state.backtracking++;
   15429         dbg.beginBacktrack(state.backtracking);
   15430         int start = input.mark();
   15431         try {
   15432             synpred132_Java_fragment(); // can never throw exception
   15433         } catch (RecognitionException re) {
   15434             System.err.println("impossible: "+re);
   15435         }
   15436         boolean success = !state.failed;
   15437         input.rewind(start);
   15438         dbg.endBacktrack(state.backtracking, success);
   15439         state.backtracking--;
   15440         state.failed=false;
   15441         return success;
   15442     }
   15443     public final boolean synpred119_Java() {
   15444         state.backtracking++;
   15445         dbg.beginBacktrack(state.backtracking);
   15446         int start = input.mark();
   15447         try {
   15448             synpred119_Java_fragment(); // can never throw exception
   15449         } catch (RecognitionException re) {
   15450             System.err.println("impossible: "+re);
   15451         }
   15452         boolean success = !state.failed;
   15453         input.rewind(start);
   15454         dbg.endBacktrack(state.backtracking, success);
   15455         state.backtracking--;
   15456         state.failed=false;
   15457         return success;
   15458     }
   15459     public final boolean synpred54_Java() {
   15460         state.backtracking++;
   15461         dbg.beginBacktrack(state.backtracking);
   15462         int start = input.mark();
   15463         try {
   15464             synpred54_Java_fragment(); // can never throw exception
   15465         } catch (RecognitionException re) {
   15466             System.err.println("impossible: "+re);
   15467         }
   15468         boolean success = !state.failed;
   15469         input.rewind(start);
   15470         dbg.endBacktrack(state.backtracking, success);
   15471         state.backtracking--;
   15472         state.failed=false;
   15473         return success;
   15474     }
   15475     public final boolean synpred148_Java() {
   15476         state.backtracking++;
   15477         dbg.beginBacktrack(state.backtracking);
   15478         int start = input.mark();
   15479         try {
   15480             synpred148_Java_fragment(); // can never throw exception
   15481         } catch (RecognitionException re) {
   15482             System.err.println("impossible: "+re);
   15483         }
   15484         boolean success = !state.failed;
   15485         input.rewind(start);
   15486         dbg.endBacktrack(state.backtracking, success);
   15487         state.backtracking--;
   15488         state.failed=false;
   15489         return success;
   15490     }
   15491     public final boolean synpred117_Java() {
   15492         state.backtracking++;
   15493         dbg.beginBacktrack(state.backtracking);
   15494         int start = input.mark();
   15495         try {
   15496             synpred117_Java_fragment(); // can never throw exception
   15497         } catch (RecognitionException re) {
   15498             System.err.println("impossible: "+re);
   15499         }
   15500         boolean success = !state.failed;
   15501         input.rewind(start);
   15502         dbg.endBacktrack(state.backtracking, success);
   15503         state.backtracking--;
   15504         state.failed=false;
   15505         return success;
   15506     }
   15507     public final boolean synpred2_Java() {
   15508         state.backtracking++;
   15509         dbg.beginBacktrack(state.backtracking);
   15510         int start = input.mark();
   15511         try {
   15512             synpred2_Java_fragment(); // can never throw exception
   15513         } catch (RecognitionException re) {
   15514             System.err.println("impossible: "+re);
   15515         }
   15516         boolean success = !state.failed;
   15517         input.rewind(start);
   15518         dbg.endBacktrack(state.backtracking, success);
   15519         state.backtracking--;
   15520         state.failed=false;
   15521         return success;
   15522     }
   15523     public final boolean synpred130_Java() {
   15524         state.backtracking++;
   15525         dbg.beginBacktrack(state.backtracking);
   15526         int start = input.mark();
   15527         try {
   15528             synpred130_Java_fragment(); // can never throw exception
   15529         } catch (RecognitionException re) {
   15530             System.err.println("impossible: "+re);
   15531         }
   15532         boolean success = !state.failed;
   15533         input.rewind(start);
   15534         dbg.endBacktrack(state.backtracking, success);
   15535         state.backtracking--;
   15536         state.failed=false;
   15537         return success;
   15538     }
   15539     public final boolean synpred126_Java() {
   15540         state.backtracking++;
   15541         dbg.beginBacktrack(state.backtracking);
   15542         int start = input.mark();
   15543         try {
   15544             synpred126_Java_fragment(); // can never throw exception
   15545         } catch (RecognitionException re) {
   15546             System.err.println("impossible: "+re);
   15547         }
   15548         boolean success = !state.failed;
   15549         input.rewind(start);
   15550         dbg.endBacktrack(state.backtracking, success);
   15551         state.backtracking--;
   15552         state.failed=false;
   15553         return success;
   15554     }
   15555     public final boolean synpred59_Java() {
   15556         state.backtracking++;
   15557         dbg.beginBacktrack(state.backtracking);
   15558         int start = input.mark();
   15559         try {
   15560             synpred59_Java_fragment(); // can never throw exception
   15561         } catch (RecognitionException re) {
   15562             System.err.println("impossible: "+re);
   15563         }
   15564         boolean success = !state.failed;
   15565         input.rewind(start);
   15566         dbg.endBacktrack(state.backtracking, success);
   15567         state.backtracking--;
   15568         state.failed=false;
   15569         return success;
   15570     }
   15571     public final boolean synpred212_Java() {
   15572         state.backtracking++;
   15573         dbg.beginBacktrack(state.backtracking);
   15574         int start = input.mark();
   15575         try {
   15576             synpred212_Java_fragment(); // can never throw exception
   15577         } catch (RecognitionException re) {
   15578             System.err.println("impossible: "+re);
   15579         }
   15580         boolean success = !state.failed;
   15581         input.rewind(start);
   15582         dbg.endBacktrack(state.backtracking, success);
   15583         state.backtracking--;
   15584         state.failed=false;
   15585         return success;
   15586     }
   15587     public final boolean synpred161_Java() {
   15588         state.backtracking++;
   15589         dbg.beginBacktrack(state.backtracking);
   15590         int start = input.mark();
   15591         try {
   15592             synpred161_Java_fragment(); // can never throw exception
   15593         } catch (RecognitionException re) {
   15594             System.err.println("impossible: "+re);
   15595         }
   15596         boolean success = !state.failed;
   15597         input.rewind(start);
   15598         dbg.endBacktrack(state.backtracking, success);
   15599         state.backtracking--;
   15600         state.failed=false;
   15601         return success;
   15602     }
   15603     public final boolean synpred57_Java() {
   15604         state.backtracking++;
   15605         dbg.beginBacktrack(state.backtracking);
   15606         int start = input.mark();
   15607         try {
   15608             synpred57_Java_fragment(); // can never throw exception
   15609         } catch (RecognitionException re) {
   15610             System.err.println("impossible: "+re);
   15611         }
   15612         boolean success = !state.failed;
   15613         input.rewind(start);
   15614         dbg.endBacktrack(state.backtracking, success);
   15615         state.backtracking--;
   15616         state.failed=false;
   15617         return success;
   15618     }
   15619     public final boolean synpred209_Java() {
   15620         state.backtracking++;
   15621         dbg.beginBacktrack(state.backtracking);
   15622         int start = input.mark();
   15623         try {
   15624             synpred209_Java_fragment(); // can never throw exception
   15625         } catch (RecognitionException re) {
   15626             System.err.println("impossible: "+re);
   15627         }
   15628         boolean success = !state.failed;
   15629         input.rewind(start);
   15630         dbg.endBacktrack(state.backtracking, success);
   15631         state.backtracking--;
   15632         state.failed=false;
   15633         return success;
   15634     }
   15635     public final boolean synpred68_Java() {
   15636         state.backtracking++;
   15637         dbg.beginBacktrack(state.backtracking);
   15638         int start = input.mark();
   15639         try {
   15640             synpred68_Java_fragment(); // can never throw exception
   15641         } catch (RecognitionException re) {
   15642             System.err.println("impossible: "+re);
   15643         }
   15644         boolean success = !state.failed;
   15645         input.rewind(start);
   15646         dbg.endBacktrack(state.backtracking, success);
   15647         state.backtracking--;
   15648         state.failed=false;
   15649         return success;
   15650     }
   15651     public final boolean synpred53_Java() {
   15652         state.backtracking++;
   15653         dbg.beginBacktrack(state.backtracking);
   15654         int start = input.mark();
   15655         try {
   15656             synpred53_Java_fragment(); // can never throw exception
   15657         } catch (RecognitionException re) {
   15658             System.err.println("impossible: "+re);
   15659         }
   15660         boolean success = !state.failed;
   15661         input.rewind(start);
   15662         dbg.endBacktrack(state.backtracking, success);
   15663         state.backtracking--;
   15664         state.failed=false;
   15665         return success;
   15666     }
   15667     public final boolean synpred52_Java() {
   15668         state.backtracking++;
   15669         dbg.beginBacktrack(state.backtracking);
   15670         int start = input.mark();
   15671         try {
   15672             synpred52_Java_fragment(); // can never throw exception
   15673         } catch (RecognitionException re) {
   15674             System.err.println("impossible: "+re);
   15675         }
   15676         boolean success = !state.failed;
   15677         input.rewind(start);
   15678         dbg.endBacktrack(state.backtracking, success);
   15679         state.backtracking--;
   15680         state.failed=false;
   15681         return success;
   15682     }
   15683     public final boolean synpred236_Java() {
   15684         state.backtracking++;
   15685         dbg.beginBacktrack(state.backtracking);
   15686         int start = input.mark();
   15687         try {
   15688             synpred236_Java_fragment(); // can never throw exception
   15689         } catch (RecognitionException re) {
   15690             System.err.println("impossible: "+re);
   15691         }
   15692         boolean success = !state.failed;
   15693         input.rewind(start);
   15694         dbg.endBacktrack(state.backtracking, success);
   15695         state.backtracking--;
   15696         state.failed=false;
   15697         return success;
   15698     }
   15699     public final boolean synpred12_Java() {
   15700         state.backtracking++;
   15701         dbg.beginBacktrack(state.backtracking);
   15702         int start = input.mark();
   15703         try {
   15704             synpred12_Java_fragment(); // can never throw exception
   15705         } catch (RecognitionException re) {
   15706             System.err.println("impossible: "+re);
   15707         }
   15708         boolean success = !state.failed;
   15709         input.rewind(start);
   15710         dbg.endBacktrack(state.backtracking, success);
   15711         state.backtracking--;
   15712         state.failed=false;
   15713         return success;
   15714     }
   15715     public final boolean synpred149_Java() {
   15716         state.backtracking++;
   15717         dbg.beginBacktrack(state.backtracking);
   15718         int start = input.mark();
   15719         try {
   15720             synpred149_Java_fragment(); // can never throw exception
   15721         } catch (RecognitionException re) {
   15722             System.err.println("impossible: "+re);
   15723         }
   15724         boolean success = !state.failed;
   15725         input.rewind(start);
   15726         dbg.endBacktrack(state.backtracking, success);
   15727         state.backtracking--;
   15728         state.failed=false;
   15729         return success;
   15730     }
   15731     public final boolean synpred120_Java() {
   15732         state.backtracking++;
   15733         dbg.beginBacktrack(state.backtracking);
   15734         int start = input.mark();
   15735         try {
   15736             synpred120_Java_fragment(); // can never throw exception
   15737         } catch (RecognitionException re) {
   15738             System.err.println("impossible: "+re);
   15739         }
   15740         boolean success = !state.failed;
   15741         input.rewind(start);
   15742         dbg.endBacktrack(state.backtracking, success);
   15743         state.backtracking--;
   15744         state.failed=false;
   15745         return success;
   15746     }
   15747     public final boolean synpred122_Java() {
   15748         state.backtracking++;
   15749         dbg.beginBacktrack(state.backtracking);
   15750         int start = input.mark();
   15751         try {
   15752             synpred122_Java_fragment(); // can never throw exception
   15753         } catch (RecognitionException re) {
   15754             System.err.println("impossible: "+re);
   15755         }
   15756         boolean success = !state.failed;
   15757         input.rewind(start);
   15758         dbg.endBacktrack(state.backtracking, success);
   15759         state.backtracking--;
   15760         state.failed=false;
   15761         return success;
   15762     }
   15763     public final boolean synpred240_Java() {
   15764         state.backtracking++;
   15765         dbg.beginBacktrack(state.backtracking);
   15766         int start = input.mark();
   15767         try {
   15768             synpred240_Java_fragment(); // can never throw exception
   15769         } catch (RecognitionException re) {
   15770             System.err.println("impossible: "+re);
   15771         }
   15772         boolean success = !state.failed;
   15773         input.rewind(start);
   15774         dbg.endBacktrack(state.backtracking, success);
   15775         state.backtracking--;
   15776         state.failed=false;
   15777         return success;
   15778     }
   15779     public final boolean synpred206_Java() {
   15780         state.backtracking++;
   15781         dbg.beginBacktrack(state.backtracking);
   15782         int start = input.mark();
   15783         try {
   15784             synpred206_Java_fragment(); // can never throw exception
   15785         } catch (RecognitionException re) {
   15786             System.err.println("impossible: "+re);
   15787         }
   15788         boolean success = !state.failed;
   15789         input.rewind(start);
   15790         dbg.endBacktrack(state.backtracking, success);
   15791         state.backtracking--;
   15792         state.failed=false;
   15793         return success;
   15794     }
   15795     public final boolean synpred70_Java() {
   15796         state.backtracking++;
   15797         dbg.beginBacktrack(state.backtracking);
   15798         int start = input.mark();
   15799         try {
   15800             synpred70_Java_fragment(); // can never throw exception
   15801         } catch (RecognitionException re) {
   15802             System.err.println("impossible: "+re);
   15803         }
   15804         boolean success = !state.failed;
   15805         input.rewind(start);
   15806         dbg.endBacktrack(state.backtracking, success);
   15807         state.backtracking--;
   15808         state.failed=false;
   15809         return success;
   15810     }
   15811     public final boolean synpred27_Java() {
   15812         state.backtracking++;
   15813         dbg.beginBacktrack(state.backtracking);
   15814         int start = input.mark();
   15815         try {
   15816             synpred27_Java_fragment(); // can never throw exception
   15817         } catch (RecognitionException re) {
   15818             System.err.println("impossible: "+re);
   15819         }
   15820         boolean success = !state.failed;
   15821         input.rewind(start);
   15822         dbg.endBacktrack(state.backtracking, success);
   15823         state.backtracking--;
   15824         state.failed=false;
   15825         return success;
   15826     }
   15827     public final boolean synpred96_Java() {
   15828         state.backtracking++;
   15829         dbg.beginBacktrack(state.backtracking);
   15830         int start = input.mark();
   15831         try {
   15832             synpred96_Java_fragment(); // can never throw exception
   15833         } catch (RecognitionException re) {
   15834             System.err.println("impossible: "+re);
   15835         }
   15836         boolean success = !state.failed;
   15837         input.rewind(start);
   15838         dbg.endBacktrack(state.backtracking, success);
   15839         state.backtracking--;
   15840         state.failed=false;
   15841         return success;
   15842     }
   15843     public final boolean synpred153_Java() {
   15844         state.backtracking++;
   15845         dbg.beginBacktrack(state.backtracking);
   15846         int start = input.mark();
   15847         try {
   15848             synpred153_Java_fragment(); // can never throw exception
   15849         } catch (RecognitionException re) {
   15850             System.err.println("impossible: "+re);
   15851         }
   15852         boolean success = !state.failed;
   15853         input.rewind(start);
   15854         dbg.endBacktrack(state.backtracking, success);
   15855         state.backtracking--;
   15856         state.failed=false;
   15857         return success;
   15858     }
   15859     public final boolean synpred99_Java() {
   15860         state.backtracking++;
   15861         dbg.beginBacktrack(state.backtracking);
   15862         int start = input.mark();
   15863         try {
   15864             synpred99_Java_fragment(); // can never throw exception
   15865         } catch (RecognitionException re) {
   15866             System.err.println("impossible: "+re);
   15867         }
   15868         boolean success = !state.failed;
   15869         input.rewind(start);
   15870         dbg.endBacktrack(state.backtracking, success);
   15871         state.backtracking--;
   15872         state.failed=false;
   15873         return success;
   15874     }
   15875     public final boolean synpred103_Java() {
   15876         state.backtracking++;
   15877         dbg.beginBacktrack(state.backtracking);
   15878         int start = input.mark();
   15879         try {
   15880             synpred103_Java_fragment(); // can never throw exception
   15881         } catch (RecognitionException re) {
   15882             System.err.println("impossible: "+re);
   15883         }
   15884         boolean success = !state.failed;
   15885         input.rewind(start);
   15886         dbg.endBacktrack(state.backtracking, success);
   15887         state.backtracking--;
   15888         state.failed=false;
   15889         return success;
   15890     }
   15891     public final boolean synpred237_Java() {
   15892         state.backtracking++;
   15893         dbg.beginBacktrack(state.backtracking);
   15894         int start = input.mark();
   15895         try {
   15896             synpred237_Java_fragment(); // can never throw exception
   15897         } catch (RecognitionException re) {
   15898             System.err.println("impossible: "+re);
   15899         }
   15900         boolean success = !state.failed;
   15901         input.rewind(start);
   15902         dbg.endBacktrack(state.backtracking, success);
   15903         state.backtracking--;
   15904         state.failed=false;
   15905         return success;
   15906     }
   15907     public final boolean synpred118_Java() {
   15908         state.backtracking++;
   15909         dbg.beginBacktrack(state.backtracking);
   15910         int start = input.mark();
   15911         try {
   15912             synpred118_Java_fragment(); // can never throw exception
   15913         } catch (RecognitionException re) {
   15914             System.err.println("impossible: "+re);
   15915         }
   15916         boolean success = !state.failed;
   15917         input.rewind(start);
   15918         dbg.endBacktrack(state.backtracking, success);
   15919         state.backtracking--;
   15920         state.failed=false;
   15921         return success;
   15922     }
   15923     public final boolean synpred208_Java() {
   15924         state.backtracking++;
   15925         dbg.beginBacktrack(state.backtracking);
   15926         int start = input.mark();
   15927         try {
   15928             synpred208_Java_fragment(); // can never throw exception
   15929         } catch (RecognitionException re) {
   15930             System.err.println("impossible: "+re);
   15931         }
   15932         boolean success = !state.failed;
   15933         input.rewind(start);
   15934         dbg.endBacktrack(state.backtracking, success);
   15935         state.backtracking--;
   15936         state.failed=false;
   15937         return success;
   15938     }
   15939 
   15940 
   15941     protected DFA2 dfa2 = new DFA2(this);
   15942     protected DFA12 dfa12 = new DFA12(this);
   15943     protected DFA13 dfa13 = new DFA13(this);
   15944     protected DFA15 dfa15 = new DFA15(this);
   15945     protected DFA31 dfa31 = new DFA31(this);
   15946     protected DFA39 dfa39 = new DFA39(this);
   15947     protected DFA49 dfa49 = new DFA49(this);
   15948     protected DFA42 dfa42 = new DFA42(this);
   15949     protected DFA53 dfa53 = new DFA53(this);
   15950     protected DFA76 dfa76 = new DFA76(this);
   15951     protected DFA87 dfa87 = new DFA87(this);
   15952     protected DFA90 dfa90 = new DFA90(this);
   15953     protected DFA98 dfa98 = new DFA98(this);
   15954     protected DFA109 dfa109 = new DFA109(this);
   15955     protected DFA112 dfa112 = new DFA112(this);
   15956     protected DFA130 dfa130 = new DFA130(this);
   15957     protected DFA133 dfa133 = new DFA133(this);
   15958     protected DFA135 dfa135 = new DFA135(this);
   15959     protected DFA143 dfa143 = new DFA143(this);
   15960     protected DFA142 dfa142 = new DFA142(this);
   15961     protected DFA148 dfa148 = new DFA148(this);
   15962     protected DFA171 dfa171 = new DFA171(this);
   15963     static final String DFA2_eotS =
   15964         "\24\uffff";
   15965     static final String DFA2_eofS =
   15966         "\1\3\23\uffff";
   15967     static final String DFA2_minS =
   15968         "\1\34\1\0\22\uffff";
   15969     static final String DFA2_maxS =
   15970         "\1\162\1\0\22\uffff";
   15971     static final String DFA2_acceptS =
   15972         "\2\uffff\1\1\1\2\20\uffff";
   15973     static final String DFA2_specialS =
   15974         "\1\uffff\1\0\22\uffff}>";
   15975     static final String[] DFA2_transitionS = {
   15976             "\1\3\7\uffff\1\3\6\uffff\1\3\1\uffff\1\3\6\uffff\1\3\2\uffff"+
   15977             "\1\3\1\uffff\1\3\1\uffff\1\2\3\3\2\uffff\2\3\2\uffff\1\3\3\uffff"+
   15978             "\1\3\2\uffff\1\3\7\uffff\1\3\35\uffff\1\1",
   15979             "\1\uffff",
   15980             "",
   15981             "",
   15982             "",
   15983             "",
   15984             "",
   15985             "",
   15986             "",
   15987             "",
   15988             "",
   15989             "",
   15990             "",
   15991             "",
   15992             "",
   15993             "",
   15994             "",
   15995             "",
   15996             "",
   15997             ""
   15998     };
   15999 
   16000     static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
   16001     static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
   16002     static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
   16003     static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
   16004     static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
   16005     static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
   16006     static final short[][] DFA2_transition;
   16007 
   16008     static {
   16009         int numStates = DFA2_transitionS.length;
   16010         DFA2_transition = new short[numStates][];
   16011         for (int i=0; i<numStates; i++) {
   16012             DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
   16013         }
   16014     }
   16015 
   16016     class DFA2 extends DFA {
   16017 
   16018         public DFA2(BaseRecognizer recognizer) {
   16019             this.recognizer = recognizer;
   16020             this.decisionNumber = 2;
   16021             this.eot = DFA2_eot;
   16022             this.eof = DFA2_eof;
   16023             this.min = DFA2_min;
   16024             this.max = DFA2_max;
   16025             this.accept = DFA2_accept;
   16026             this.special = DFA2_special;
   16027             this.transition = DFA2_transition;
   16028         }
   16029         public String getDescription() {
   16030             return "298:9: ( ( annotations )? packageDeclaration )?";
   16031         }
   16032         public void error(NoViableAltException nvae) {
   16033             dbg.recognitionException(nvae);
   16034         }
   16035         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   16036             TokenStream input = (TokenStream)_input;
   16037 		int _s = s;
   16038             switch ( s ) {
   16039                     case 0 :
   16040                         int LA2_1 = input.LA(1);
   16041 
   16042 
   16043                         int index2_1 = input.index();
   16044                         input.rewind();
   16045                         s = -1;
   16046                         if ( (synpred2_Java()) ) {s = 2;}
   16047 
   16048                         else if ( (true) ) {s = 3;}
   16049 
   16050 
   16051                         input.seek(index2_1);
   16052                         if ( s>=0 ) return s;
   16053                         break;
   16054             }
   16055             if (state.backtracking>0) {state.failed=true; return -1;}
   16056             NoViableAltException nvae =
   16057                 new NoViableAltException(getDescription(), 2, _s, input);
   16058             error(nvae);
   16059             throw nvae;
   16060         }
   16061     }
   16062     static final String DFA12_eotS =
   16063         "\20\uffff";
   16064     static final String DFA12_eofS =
   16065         "\20\uffff";
   16066     static final String DFA12_minS =
   16067         "\1\34\14\0\3\uffff";
   16068     static final String DFA12_maxS =
   16069         "\1\162\14\0\3\uffff";
   16070     static final String DFA12_acceptS =
   16071         "\15\uffff\1\1\1\uffff\1\2";
   16072     static final String DFA12_specialS =
   16073         "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\3\uffff}>";
   16074     static final String[] DFA12_transitionS = {
   16075             "\1\6\7\uffff\1\15\6\uffff\1\15\1\uffff\1\7\11\uffff\1\17\1\uffff"+
   16076             "\1\10\2\uffff\1\4\1\3\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff"+
   16077             "\1\12\2\uffff\1\13\45\uffff\1\1",
   16078             "\1\uffff",
   16079             "\1\uffff",
   16080             "\1\uffff",
   16081             "\1\uffff",
   16082             "\1\uffff",
   16083             "\1\uffff",
   16084             "\1\uffff",
   16085             "\1\uffff",
   16086             "\1\uffff",
   16087             "\1\uffff",
   16088             "\1\uffff",
   16089             "\1\uffff",
   16090             "",
   16091             "",
   16092             ""
   16093     };
   16094 
   16095     static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS);
   16096     static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS);
   16097     static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS);
   16098     static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS);
   16099     static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS);
   16100     static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS);
   16101     static final short[][] DFA12_transition;
   16102 
   16103     static {
   16104         int numStates = DFA12_transitionS.length;
   16105         DFA12_transition = new short[numStates][];
   16106         for (int i=0; i<numStates; i++) {
   16107             DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]);
   16108         }
   16109     }
   16110 
   16111     class DFA12 extends DFA {
   16112 
   16113         public DFA12(BaseRecognizer recognizer) {
   16114             this.recognizer = recognizer;
   16115             this.decisionNumber = 12;
   16116             this.eot = DFA12_eot;
   16117             this.eof = DFA12_eof;
   16118             this.min = DFA12_min;
   16119             this.max = DFA12_max;
   16120             this.accept = DFA12_accept;
   16121             this.special = DFA12_special;
   16122             this.transition = DFA12_transition;
   16123         }
   16124         public String getDescription() {
   16125             return "341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );";
   16126         }
   16127         public void error(NoViableAltException nvae) {
   16128             dbg.recognitionException(nvae);
   16129         }
   16130         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   16131             TokenStream input = (TokenStream)_input;
   16132 		int _s = s;
   16133             switch ( s ) {
   16134                     case 0 :
   16135                         int LA12_1 = input.LA(1);
   16136 
   16137 
   16138                         int index12_1 = input.index();
   16139                         input.rewind();
   16140                         s = -1;
   16141                         if ( (synpred12_Java()) ) {s = 13;}
   16142 
   16143                         else if ( (true) ) {s = 15;}
   16144 
   16145 
   16146                         input.seek(index12_1);
   16147                         if ( s>=0 ) return s;
   16148                         break;
   16149                     case 1 :
   16150                         int LA12_2 = input.LA(1);
   16151 
   16152 
   16153                         int index12_2 = input.index();
   16154                         input.rewind();
   16155                         s = -1;
   16156                         if ( (synpred12_Java()) ) {s = 13;}
   16157 
   16158                         else if ( (true) ) {s = 15;}
   16159 
   16160 
   16161                         input.seek(index12_2);
   16162                         if ( s>=0 ) return s;
   16163                         break;
   16164                     case 2 :
   16165                         int LA12_3 = input.LA(1);
   16166 
   16167 
   16168                         int index12_3 = input.index();
   16169                         input.rewind();
   16170                         s = -1;
   16171                         if ( (synpred12_Java()) ) {s = 13;}
   16172 
   16173                         else if ( (true) ) {s = 15;}
   16174 
   16175 
   16176                         input.seek(index12_3);
   16177                         if ( s>=0 ) return s;
   16178                         break;
   16179                     case 3 :
   16180                         int LA12_4 = input.LA(1);
   16181 
   16182 
   16183                         int index12_4 = input.index();
   16184                         input.rewind();
   16185                         s = -1;
   16186                         if ( (synpred12_Java()) ) {s = 13;}
   16187 
   16188                         else if ( (true) ) {s = 15;}
   16189 
   16190 
   16191                         input.seek(index12_4);
   16192                         if ( s>=0 ) return s;
   16193                         break;
   16194                     case 4 :
   16195                         int LA12_5 = input.LA(1);
   16196 
   16197 
   16198                         int index12_5 = input.index();
   16199                         input.rewind();
   16200                         s = -1;
   16201                         if ( (synpred12_Java()) ) {s = 13;}
   16202 
   16203                         else if ( (true) ) {s = 15;}
   16204 
   16205 
   16206                         input.seek(index12_5);
   16207                         if ( s>=0 ) return s;
   16208                         break;
   16209                     case 5 :
   16210                         int LA12_6 = input.LA(1);
   16211 
   16212 
   16213                         int index12_6 = input.index();
   16214                         input.rewind();
   16215                         s = -1;
   16216                         if ( (synpred12_Java()) ) {s = 13;}
   16217 
   16218                         else if ( (true) ) {s = 15;}
   16219 
   16220 
   16221                         input.seek(index12_6);
   16222                         if ( s>=0 ) return s;
   16223                         break;
   16224                     case 6 :
   16225                         int LA12_7 = input.LA(1);
   16226 
   16227 
   16228                         int index12_7 = input.index();
   16229                         input.rewind();
   16230                         s = -1;
   16231                         if ( (synpred12_Java()) ) {s = 13;}
   16232 
   16233                         else if ( (true) ) {s = 15;}
   16234 
   16235 
   16236                         input.seek(index12_7);
   16237                         if ( s>=0 ) return s;
   16238                         break;
   16239                     case 7 :
   16240                         int LA12_8 = input.LA(1);
   16241 
   16242 
   16243                         int index12_8 = input.index();
   16244                         input.rewind();
   16245                         s = -1;
   16246                         if ( (synpred12_Java()) ) {s = 13;}
   16247 
   16248                         else if ( (true) ) {s = 15;}
   16249 
   16250 
   16251                         input.seek(index12_8);
   16252                         if ( s>=0 ) return s;
   16253                         break;
   16254                     case 8 :
   16255                         int LA12_9 = input.LA(1);
   16256 
   16257 
   16258                         int index12_9 = input.index();
   16259                         input.rewind();
   16260                         s = -1;
   16261                         if ( (synpred12_Java()) ) {s = 13;}
   16262 
   16263                         else if ( (true) ) {s = 15;}
   16264 
   16265 
   16266                         input.seek(index12_9);
   16267                         if ( s>=0 ) return s;
   16268                         break;
   16269                     case 9 :
   16270                         int LA12_10 = input.LA(1);
   16271 
   16272 
   16273                         int index12_10 = input.index();
   16274                         input.rewind();
   16275                         s = -1;
   16276                         if ( (synpred12_Java()) ) {s = 13;}
   16277 
   16278                         else if ( (true) ) {s = 15;}
   16279 
   16280 
   16281                         input.seek(index12_10);
   16282                         if ( s>=0 ) return s;
   16283                         break;
   16284                     case 10 :
   16285                         int LA12_11 = input.LA(1);
   16286 
   16287 
   16288                         int index12_11 = input.index();
   16289                         input.rewind();
   16290                         s = -1;
   16291                         if ( (synpred12_Java()) ) {s = 13;}
   16292 
   16293                         else if ( (true) ) {s = 15;}
   16294 
   16295 
   16296                         input.seek(index12_11);
   16297                         if ( s>=0 ) return s;
   16298                         break;
   16299                     case 11 :
   16300                         int LA12_12 = input.LA(1);
   16301 
   16302 
   16303                         int index12_12 = input.index();
   16304                         input.rewind();
   16305                         s = -1;
   16306                         if ( (synpred12_Java()) ) {s = 13;}
   16307 
   16308                         else if ( (true) ) {s = 15;}
   16309 
   16310 
   16311                         input.seek(index12_12);
   16312                         if ( s>=0 ) return s;
   16313                         break;
   16314             }
   16315             if (state.backtracking>0) {state.failed=true; return -1;}
   16316             NoViableAltException nvae =
   16317                 new NoViableAltException(getDescription(), 12, _s, input);
   16318             error(nvae);
   16319             throw nvae;
   16320         }
   16321     }
   16322     static final String DFA13_eotS =
   16323         "\17\uffff";
   16324     static final String DFA13_eofS =
   16325         "\17\uffff";
   16326     static final String DFA13_minS =
   16327         "\1\4\1\uffff\1\4\14\uffff";
   16328     static final String DFA13_maxS =
   16329         "\1\165\1\uffff\1\67\14\uffff";
   16330     static final String DFA13_acceptS =
   16331         "\1\uffff\1\15\1\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13"+
   16332         "\1\14\1\1";
   16333     static final String DFA13_specialS =
   16334         "\17\uffff}>";
   16335     static final String[] DFA13_transitionS = {
   16336             "\1\1\27\uffff\1\7\1\uffff\1\1\1\uffff\1\1\2\uffff\2\1\4\uffff"+
   16337             "\1\1\1\uffff\1\1\1\uffff\1\10\1\uffff\1\1\6\uffff\3\1\1\11\2"+
   16338             "\uffff\1\5\1\4\1\3\1\uffff\1\1\1\6\1\15\2\uffff\1\12\3\uffff"+
   16339             "\1\13\1\uffff\1\1\1\14\45\uffff\1\2\2\uffff\1\1",
   16340             "",
   16341             "\1\16\62\uffff\1\1",
   16342             "",
   16343             "",
   16344             "",
   16345             "",
   16346             "",
   16347             "",
   16348             "",
   16349             "",
   16350             "",
   16351             "",
   16352             "",
   16353             ""
   16354     };
   16355 
   16356     static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
   16357     static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
   16358     static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS);
   16359     static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS);
   16360     static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
   16361     static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS);
   16362     static final short[][] DFA13_transition;
   16363 
   16364     static {
   16365         int numStates = DFA13_transitionS.length;
   16366         DFA13_transition = new short[numStates][];
   16367         for (int i=0; i<numStates; i++) {
   16368             DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]);
   16369         }
   16370     }
   16371 
   16372     class DFA13 extends DFA {
   16373 
   16374         public DFA13(BaseRecognizer recognizer) {
   16375             this.recognizer = recognizer;
   16376             this.decisionNumber = 13;
   16377             this.eot = DFA13_eot;
   16378             this.eof = DFA13_eof;
   16379             this.min = DFA13_min;
   16380             this.max = DFA13_max;
   16381             this.accept = DFA13_accept;
   16382             this.special = DFA13_special;
   16383             this.transition = DFA13_transition;
   16384         }
   16385         public String getDescription() {
   16386             return "()* loopback of 349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*";
   16387         }
   16388         public void error(NoViableAltException nvae) {
   16389             dbg.recognitionException(nvae);
   16390         }
   16391     }
   16392     static final String DFA15_eotS =
   16393         "\17\uffff";
   16394     static final String DFA15_eofS =
   16395         "\17\uffff";
   16396     static final String DFA15_minS =
   16397         "\1\34\14\0\2\uffff";
   16398     static final String DFA15_maxS =
   16399         "\1\162\14\0\2\uffff";
   16400     static final String DFA15_acceptS =
   16401         "\15\uffff\1\1\1\2";
   16402     static final String DFA15_specialS =
   16403         "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\2\uffff}>";
   16404     static final String[] DFA15_transitionS = {
   16405             "\1\6\7\uffff\1\15\6\uffff\1\16\1\uffff\1\7\13\uffff\1\10\2\uffff"+
   16406             "\1\4\1\3\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff\1\12\2\uffff"+
   16407             "\1\13\45\uffff\1\1",
   16408             "\1\uffff",
   16409             "\1\uffff",
   16410             "\1\uffff",
   16411             "\1\uffff",
   16412             "\1\uffff",
   16413             "\1\uffff",
   16414             "\1\uffff",
   16415             "\1\uffff",
   16416             "\1\uffff",
   16417             "\1\uffff",
   16418             "\1\uffff",
   16419             "\1\uffff",
   16420             "",
   16421             ""
   16422     };
   16423 
   16424     static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS);
   16425     static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS);
   16426     static final char[] DFA15_min = DFA.unpackEncodedStringToUnsignedChars(DFA15_minS);
   16427     static final char[] DFA15_max = DFA.unpackEncodedStringToUnsignedChars(DFA15_maxS);
   16428     static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS);
   16429     static final short[] DFA15_special = DFA.unpackEncodedString(DFA15_specialS);
   16430     static final short[][] DFA15_transition;
   16431 
   16432     static {
   16433         int numStates = DFA15_transitionS.length;
   16434         DFA15_transition = new short[numStates][];
   16435         for (int i=0; i<numStates; i++) {
   16436             DFA15_transition[i] = DFA.unpackEncodedString(DFA15_transitionS[i]);
   16437         }
   16438     }
   16439 
   16440     class DFA15 extends DFA {
   16441 
   16442         public DFA15(BaseRecognizer recognizer) {
   16443             this.recognizer = recognizer;
   16444             this.decisionNumber = 15;
   16445             this.eot = DFA15_eot;
   16446             this.eof = DFA15_eof;
   16447             this.min = DFA15_min;
   16448             this.max = DFA15_max;
   16449             this.accept = DFA15_accept;
   16450             this.special = DFA15_special;
   16451             this.transition = DFA15_transition;
   16452         }
   16453         public String getDescription() {
   16454             return "372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );";
   16455         }
   16456         public void error(NoViableAltException nvae) {
   16457             dbg.recognitionException(nvae);
   16458         }
   16459         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   16460             TokenStream input = (TokenStream)_input;
   16461 		int _s = s;
   16462             switch ( s ) {
   16463                     case 0 :
   16464                         int LA15_1 = input.LA(1);
   16465 
   16466 
   16467                         int index15_1 = input.index();
   16468                         input.rewind();
   16469                         s = -1;
   16470                         if ( (synpred27_Java()) ) {s = 13;}
   16471 
   16472                         else if ( (true) ) {s = 14;}
   16473 
   16474 
   16475                         input.seek(index15_1);
   16476                         if ( s>=0 ) return s;
   16477                         break;
   16478                     case 1 :
   16479                         int LA15_2 = input.LA(1);
   16480 
   16481 
   16482                         int index15_2 = input.index();
   16483                         input.rewind();
   16484                         s = -1;
   16485                         if ( (synpred27_Java()) ) {s = 13;}
   16486 
   16487                         else if ( (true) ) {s = 14;}
   16488 
   16489 
   16490                         input.seek(index15_2);
   16491                         if ( s>=0 ) return s;
   16492                         break;
   16493                     case 2 :
   16494                         int LA15_3 = input.LA(1);
   16495 
   16496 
   16497                         int index15_3 = input.index();
   16498                         input.rewind();
   16499                         s = -1;
   16500                         if ( (synpred27_Java()) ) {s = 13;}
   16501 
   16502                         else if ( (true) ) {s = 14;}
   16503 
   16504 
   16505                         input.seek(index15_3);
   16506                         if ( s>=0 ) return s;
   16507                         break;
   16508                     case 3 :
   16509                         int LA15_4 = input.LA(1);
   16510 
   16511 
   16512                         int index15_4 = input.index();
   16513                         input.rewind();
   16514                         s = -1;
   16515                         if ( (synpred27_Java()) ) {s = 13;}
   16516 
   16517                         else if ( (true) ) {s = 14;}
   16518 
   16519 
   16520                         input.seek(index15_4);
   16521                         if ( s>=0 ) return s;
   16522                         break;
   16523                     case 4 :
   16524                         int LA15_5 = input.LA(1);
   16525 
   16526 
   16527                         int index15_5 = input.index();
   16528                         input.rewind();
   16529                         s = -1;
   16530                         if ( (synpred27_Java()) ) {s = 13;}
   16531 
   16532                         else if ( (true) ) {s = 14;}
   16533 
   16534 
   16535                         input.seek(index15_5);
   16536                         if ( s>=0 ) return s;
   16537                         break;
   16538                     case 5 :
   16539                         int LA15_6 = input.LA(1);
   16540 
   16541 
   16542                         int index15_6 = input.index();
   16543                         input.rewind();
   16544                         s = -1;
   16545                         if ( (synpred27_Java()) ) {s = 13;}
   16546 
   16547                         else if ( (true) ) {s = 14;}
   16548 
   16549 
   16550                         input.seek(index15_6);
   16551                         if ( s>=0 ) return s;
   16552                         break;
   16553                     case 6 :
   16554                         int LA15_7 = input.LA(1);
   16555 
   16556 
   16557                         int index15_7 = input.index();
   16558                         input.rewind();
   16559                         s = -1;
   16560                         if ( (synpred27_Java()) ) {s = 13;}
   16561 
   16562                         else if ( (true) ) {s = 14;}
   16563 
   16564 
   16565                         input.seek(index15_7);
   16566                         if ( s>=0 ) return s;
   16567                         break;
   16568                     case 7 :
   16569                         int LA15_8 = input.LA(1);
   16570 
   16571 
   16572                         int index15_8 = input.index();
   16573                         input.rewind();
   16574                         s = -1;
   16575                         if ( (synpred27_Java()) ) {s = 13;}
   16576 
   16577                         else if ( (true) ) {s = 14;}
   16578 
   16579 
   16580                         input.seek(index15_8);
   16581                         if ( s>=0 ) return s;
   16582                         break;
   16583                     case 8 :
   16584                         int LA15_9 = input.LA(1);
   16585 
   16586 
   16587                         int index15_9 = input.index();
   16588                         input.rewind();
   16589                         s = -1;
   16590                         if ( (synpred27_Java()) ) {s = 13;}
   16591 
   16592                         else if ( (true) ) {s = 14;}
   16593 
   16594 
   16595                         input.seek(index15_9);
   16596                         if ( s>=0 ) return s;
   16597                         break;
   16598                     case 9 :
   16599                         int LA15_10 = input.LA(1);
   16600 
   16601 
   16602                         int index15_10 = input.index();
   16603                         input.rewind();
   16604                         s = -1;
   16605                         if ( (synpred27_Java()) ) {s = 13;}
   16606 
   16607                         else if ( (true) ) {s = 14;}
   16608 
   16609 
   16610                         input.seek(index15_10);
   16611                         if ( s>=0 ) return s;
   16612                         break;
   16613                     case 10 :
   16614                         int LA15_11 = input.LA(1);
   16615 
   16616 
   16617                         int index15_11 = input.index();
   16618                         input.rewind();
   16619                         s = -1;
   16620                         if ( (synpred27_Java()) ) {s = 13;}
   16621 
   16622                         else if ( (true) ) {s = 14;}
   16623 
   16624 
   16625                         input.seek(index15_11);
   16626                         if ( s>=0 ) return s;
   16627                         break;
   16628                     case 11 :
   16629                         int LA15_12 = input.LA(1);
   16630 
   16631 
   16632                         int index15_12 = input.index();
   16633                         input.rewind();
   16634                         s = -1;
   16635                         if ( (synpred27_Java()) ) {s = 13;}
   16636 
   16637                         else if ( (true) ) {s = 14;}
   16638 
   16639 
   16640                         input.seek(index15_12);
   16641                         if ( s>=0 ) return s;
   16642                         break;
   16643             }
   16644             if (state.backtracking>0) {state.failed=true; return -1;}
   16645             NoViableAltException nvae =
   16646                 new NoViableAltException(getDescription(), 15, _s, input);
   16647             error(nvae);
   16648             throw nvae;
   16649         }
   16650     }
   16651     static final String DFA31_eotS =
   16652         "\17\uffff";
   16653     static final String DFA31_eofS =
   16654         "\17\uffff";
   16655     static final String DFA31_minS =
   16656         "\1\34\14\0\2\uffff";
   16657     static final String DFA31_maxS =
   16658         "\1\162\14\0\2\uffff";
   16659     static final String DFA31_acceptS =
   16660         "\15\uffff\1\1\1\2";
   16661     static final String DFA31_specialS =
   16662         "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\2\uffff}>";
   16663     static final String[] DFA31_transitionS = {
   16664             "\1\6\20\uffff\1\7\11\uffff\1\15\1\uffff\1\10\2\uffff\1\4\1\3"+
   16665             "\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff\1\12\2\uffff\1\13"+
   16666             "\45\uffff\1\1",
   16667             "\1\uffff",
   16668             "\1\uffff",
   16669             "\1\uffff",
   16670             "\1\uffff",
   16671             "\1\uffff",
   16672             "\1\uffff",
   16673             "\1\uffff",
   16674             "\1\uffff",
   16675             "\1\uffff",
   16676             "\1\uffff",
   16677             "\1\uffff",
   16678             "\1\uffff",
   16679             "",
   16680             ""
   16681     };
   16682 
   16683     static final short[] DFA31_eot = DFA.unpackEncodedString(DFA31_eotS);
   16684     static final short[] DFA31_eof = DFA.unpackEncodedString(DFA31_eofS);
   16685     static final char[] DFA31_min = DFA.unpackEncodedStringToUnsignedChars(DFA31_minS);
   16686     static final char[] DFA31_max = DFA.unpackEncodedStringToUnsignedChars(DFA31_maxS);
   16687     static final short[] DFA31_accept = DFA.unpackEncodedString(DFA31_acceptS);
   16688     static final short[] DFA31_special = DFA.unpackEncodedString(DFA31_specialS);
   16689     static final short[][] DFA31_transition;
   16690 
   16691     static {
   16692         int numStates = DFA31_transitionS.length;
   16693         DFA31_transition = new short[numStates][];
   16694         for (int i=0; i<numStates; i++) {
   16695             DFA31_transition[i] = DFA.unpackEncodedString(DFA31_transitionS[i]);
   16696         }
   16697     }
   16698 
   16699     class DFA31 extends DFA {
   16700 
   16701         public DFA31(BaseRecognizer recognizer) {
   16702             this.recognizer = recognizer;
   16703             this.decisionNumber = 31;
   16704             this.eot = DFA31_eot;
   16705             this.eof = DFA31_eof;
   16706             this.min = DFA31_min;
   16707             this.max = DFA31_max;
   16708             this.accept = DFA31_accept;
   16709             this.special = DFA31_special;
   16710             this.transition = DFA31_transition;
   16711         }
   16712         public String getDescription() {
   16713             return "460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );";
   16714         }
   16715         public void error(NoViableAltException nvae) {
   16716             dbg.recognitionException(nvae);
   16717         }
   16718         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   16719             TokenStream input = (TokenStream)_input;
   16720 		int _s = s;
   16721             switch ( s ) {
   16722                     case 0 :
   16723                         int LA31_1 = input.LA(1);
   16724 
   16725 
   16726                         int index31_1 = input.index();
   16727                         input.rewind();
   16728                         s = -1;
   16729                         if ( (synpred43_Java()) ) {s = 13;}
   16730 
   16731                         else if ( (true) ) {s = 14;}
   16732 
   16733 
   16734                         input.seek(index31_1);
   16735                         if ( s>=0 ) return s;
   16736                         break;
   16737                     case 1 :
   16738                         int LA31_2 = input.LA(1);
   16739 
   16740 
   16741                         int index31_2 = input.index();
   16742                         input.rewind();
   16743                         s = -1;
   16744                         if ( (synpred43_Java()) ) {s = 13;}
   16745 
   16746                         else if ( (true) ) {s = 14;}
   16747 
   16748 
   16749                         input.seek(index31_2);
   16750                         if ( s>=0 ) return s;
   16751                         break;
   16752                     case 2 :
   16753                         int LA31_3 = input.LA(1);
   16754 
   16755 
   16756                         int index31_3 = input.index();
   16757                         input.rewind();
   16758                         s = -1;
   16759                         if ( (synpred43_Java()) ) {s = 13;}
   16760 
   16761                         else if ( (true) ) {s = 14;}
   16762 
   16763 
   16764                         input.seek(index31_3);
   16765                         if ( s>=0 ) return s;
   16766                         break;
   16767                     case 3 :
   16768                         int LA31_4 = input.LA(1);
   16769 
   16770 
   16771                         int index31_4 = input.index();
   16772                         input.rewind();
   16773                         s = -1;
   16774                         if ( (synpred43_Java()) ) {s = 13;}
   16775 
   16776                         else if ( (true) ) {s = 14;}
   16777 
   16778 
   16779                         input.seek(index31_4);
   16780                         if ( s>=0 ) return s;
   16781                         break;
   16782                     case 4 :
   16783                         int LA31_5 = input.LA(1);
   16784 
   16785 
   16786                         int index31_5 = input.index();
   16787                         input.rewind();
   16788                         s = -1;
   16789                         if ( (synpred43_Java()) ) {s = 13;}
   16790 
   16791                         else if ( (true) ) {s = 14;}
   16792 
   16793 
   16794                         input.seek(index31_5);
   16795                         if ( s>=0 ) return s;
   16796                         break;
   16797                     case 5 :
   16798                         int LA31_6 = input.LA(1);
   16799 
   16800 
   16801                         int index31_6 = input.index();
   16802                         input.rewind();
   16803                         s = -1;
   16804                         if ( (synpred43_Java()) ) {s = 13;}
   16805 
   16806                         else if ( (true) ) {s = 14;}
   16807 
   16808 
   16809                         input.seek(index31_6);
   16810                         if ( s>=0 ) return s;
   16811                         break;
   16812                     case 6 :
   16813                         int LA31_7 = input.LA(1);
   16814 
   16815 
   16816                         int index31_7 = input.index();
   16817                         input.rewind();
   16818                         s = -1;
   16819                         if ( (synpred43_Java()) ) {s = 13;}
   16820 
   16821                         else if ( (true) ) {s = 14;}
   16822 
   16823 
   16824                         input.seek(index31_7);
   16825                         if ( s>=0 ) return s;
   16826                         break;
   16827                     case 7 :
   16828                         int LA31_8 = input.LA(1);
   16829 
   16830 
   16831                         int index31_8 = input.index();
   16832                         input.rewind();
   16833                         s = -1;
   16834                         if ( (synpred43_Java()) ) {s = 13;}
   16835 
   16836                         else if ( (true) ) {s = 14;}
   16837 
   16838 
   16839                         input.seek(index31_8);
   16840                         if ( s>=0 ) return s;
   16841                         break;
   16842                     case 8 :
   16843                         int LA31_9 = input.LA(1);
   16844 
   16845 
   16846                         int index31_9 = input.index();
   16847                         input.rewind();
   16848                         s = -1;
   16849                         if ( (synpred43_Java()) ) {s = 13;}
   16850 
   16851                         else if ( (true) ) {s = 14;}
   16852 
   16853 
   16854                         input.seek(index31_9);
   16855                         if ( s>=0 ) return s;
   16856                         break;
   16857                     case 9 :
   16858                         int LA31_10 = input.LA(1);
   16859 
   16860 
   16861                         int index31_10 = input.index();
   16862                         input.rewind();
   16863                         s = -1;
   16864                         if ( (synpred43_Java()) ) {s = 13;}
   16865 
   16866                         else if ( (true) ) {s = 14;}
   16867 
   16868 
   16869                         input.seek(index31_10);
   16870                         if ( s>=0 ) return s;
   16871                         break;
   16872                     case 10 :
   16873                         int LA31_11 = input.LA(1);
   16874 
   16875 
   16876                         int index31_11 = input.index();
   16877                         input.rewind();
   16878                         s = -1;
   16879                         if ( (synpred43_Java()) ) {s = 13;}
   16880 
   16881                         else if ( (true) ) {s = 14;}
   16882 
   16883 
   16884                         input.seek(index31_11);
   16885                         if ( s>=0 ) return s;
   16886                         break;
   16887                     case 11 :
   16888                         int LA31_12 = input.LA(1);
   16889 
   16890 
   16891                         int index31_12 = input.index();
   16892                         input.rewind();
   16893                         s = -1;
   16894                         if ( (synpred43_Java()) ) {s = 13;}
   16895 
   16896                         else if ( (true) ) {s = 14;}
   16897 
   16898 
   16899                         input.seek(index31_12);
   16900                         if ( s>=0 ) return s;
   16901                         break;
   16902             }
   16903             if (state.backtracking>0) {state.failed=true; return -1;}
   16904             NoViableAltException nvae =
   16905                 new NoViableAltException(getDescription(), 31, _s, input);
   16906             error(nvae);
   16907             throw nvae;
   16908         }
   16909     }
   16910     static final String DFA39_eotS =
   16911         "\25\uffff";
   16912     static final String DFA39_eofS =
   16913         "\25\uffff";
   16914     static final String DFA39_minS =
   16915         "\1\4\16\0\6\uffff";
   16916     static final String DFA39_maxS =
   16917         "\1\165\16\0\6\uffff";
   16918     static final String DFA39_acceptS =
   16919         "\17\uffff\1\2\1\uffff\1\3\1\uffff\1\4\1\1";
   16920     static final String DFA39_specialS =
   16921         "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
   16922         "\1\15\6\uffff}>";
   16923     static final String[] DFA39_transitionS = {
   16924             "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+
   16925             "\21\4\uffff\1\16\1\uffff\1\21\1\uffff\1\7\1\uffff\1\16\6\uffff"+
   16926             "\1\16\1\23\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+
   16927             "\14\2\uffff\1\11\3\uffff\1\12\1\uffff\1\17\1\13\45\uffff\1\1"+
   16928             "\2\uffff\1\17",
   16929             "\1\uffff",
   16930             "\1\uffff",
   16931             "\1\uffff",
   16932             "\1\uffff",
   16933             "\1\uffff",
   16934             "\1\uffff",
   16935             "\1\uffff",
   16936             "\1\uffff",
   16937             "\1\uffff",
   16938             "\1\uffff",
   16939             "\1\uffff",
   16940             "\1\uffff",
   16941             "\1\uffff",
   16942             "\1\uffff",
   16943             "",
   16944             "",
   16945             "",
   16946             "",
   16947             "",
   16948             ""
   16949     };
   16950 
   16951     static final short[] DFA39_eot = DFA.unpackEncodedString(DFA39_eotS);
   16952     static final short[] DFA39_eof = DFA.unpackEncodedString(DFA39_eofS);
   16953     static final char[] DFA39_min = DFA.unpackEncodedStringToUnsignedChars(DFA39_minS);
   16954     static final char[] DFA39_max = DFA.unpackEncodedStringToUnsignedChars(DFA39_maxS);
   16955     static final short[] DFA39_accept = DFA.unpackEncodedString(DFA39_acceptS);
   16956     static final short[] DFA39_special = DFA.unpackEncodedString(DFA39_specialS);
   16957     static final short[][] DFA39_transition;
   16958 
   16959     static {
   16960         int numStates = DFA39_transitionS.length;
   16961         DFA39_transition = new short[numStates][];
   16962         for (int i=0; i<numStates; i++) {
   16963             DFA39_transition[i] = DFA.unpackEncodedString(DFA39_transitionS[i]);
   16964         }
   16965     }
   16966 
   16967     class DFA39 extends DFA {
   16968 
   16969         public DFA39(BaseRecognizer recognizer) {
   16970             this.recognizer = recognizer;
   16971             this.decisionNumber = 39;
   16972             this.eot = DFA39_eot;
   16973             this.eof = DFA39_eof;
   16974             this.min = DFA39_min;
   16975             this.max = DFA39_max;
   16976             this.accept = DFA39_accept;
   16977             this.special = DFA39_special;
   16978             this.transition = DFA39_transition;
   16979         }
   16980         public String getDescription() {
   16981             return "502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );";
   16982         }
   16983         public void error(NoViableAltException nvae) {
   16984             dbg.recognitionException(nvae);
   16985         }
   16986         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   16987             TokenStream input = (TokenStream)_input;
   16988 		int _s = s;
   16989             switch ( s ) {
   16990                     case 0 :
   16991                         int LA39_1 = input.LA(1);
   16992 
   16993 
   16994                         int index39_1 = input.index();
   16995                         input.rewind();
   16996                         s = -1;
   16997                         if ( (synpred52_Java()) ) {s = 20;}
   16998 
   16999                         else if ( (synpred53_Java()) ) {s = 15;}
   17000 
   17001                         else if ( (synpred54_Java()) ) {s = 17;}
   17002 
   17003                         else if ( (true) ) {s = 19;}
   17004 
   17005 
   17006                         input.seek(index39_1);
   17007                         if ( s>=0 ) return s;
   17008                         break;
   17009                     case 1 :
   17010                         int LA39_2 = input.LA(1);
   17011 
   17012 
   17013                         int index39_2 = input.index();
   17014                         input.rewind();
   17015                         s = -1;
   17016                         if ( (synpred52_Java()) ) {s = 20;}
   17017 
   17018                         else if ( (synpred53_Java()) ) {s = 15;}
   17019 
   17020                         else if ( (synpred54_Java()) ) {s = 17;}
   17021 
   17022                         else if ( (true) ) {s = 19;}
   17023 
   17024 
   17025                         input.seek(index39_2);
   17026                         if ( s>=0 ) return s;
   17027                         break;
   17028                     case 2 :
   17029                         int LA39_3 = input.LA(1);
   17030 
   17031 
   17032                         int index39_3 = input.index();
   17033                         input.rewind();
   17034                         s = -1;
   17035                         if ( (synpred52_Java()) ) {s = 20;}
   17036 
   17037                         else if ( (synpred53_Java()) ) {s = 15;}
   17038 
   17039                         else if ( (synpred54_Java()) ) {s = 17;}
   17040 
   17041                         else if ( (true) ) {s = 19;}
   17042 
   17043 
   17044                         input.seek(index39_3);
   17045                         if ( s>=0 ) return s;
   17046                         break;
   17047                     case 3 :
   17048                         int LA39_4 = input.LA(1);
   17049 
   17050 
   17051                         int index39_4 = input.index();
   17052                         input.rewind();
   17053                         s = -1;
   17054                         if ( (synpred52_Java()) ) {s = 20;}
   17055 
   17056                         else if ( (synpred53_Java()) ) {s = 15;}
   17057 
   17058                         else if ( (synpred54_Java()) ) {s = 17;}
   17059 
   17060                         else if ( (true) ) {s = 19;}
   17061 
   17062 
   17063                         input.seek(index39_4);
   17064                         if ( s>=0 ) return s;
   17065                         break;
   17066                     case 4 :
   17067                         int LA39_5 = input.LA(1);
   17068 
   17069 
   17070                         int index39_5 = input.index();
   17071                         input.rewind();
   17072                         s = -1;
   17073                         if ( (synpred52_Java()) ) {s = 20;}
   17074 
   17075                         else if ( (synpred53_Java()) ) {s = 15;}
   17076 
   17077                         else if ( (synpred54_Java()) ) {s = 17;}
   17078 
   17079                         else if ( (true) ) {s = 19;}
   17080 
   17081 
   17082                         input.seek(index39_5);
   17083                         if ( s>=0 ) return s;
   17084                         break;
   17085                     case 5 :
   17086                         int LA39_6 = input.LA(1);
   17087 
   17088 
   17089                         int index39_6 = input.index();
   17090                         input.rewind();
   17091                         s = -1;
   17092                         if ( (synpred52_Java()) ) {s = 20;}
   17093 
   17094                         else if ( (synpred53_Java()) ) {s = 15;}
   17095 
   17096                         else if ( (synpred54_Java()) ) {s = 17;}
   17097 
   17098                         else if ( (true) ) {s = 19;}
   17099 
   17100 
   17101                         input.seek(index39_6);
   17102                         if ( s>=0 ) return s;
   17103                         break;
   17104                     case 6 :
   17105                         int LA39_7 = input.LA(1);
   17106 
   17107 
   17108                         int index39_7 = input.index();
   17109                         input.rewind();
   17110                         s = -1;
   17111                         if ( (synpred52_Java()) ) {s = 20;}
   17112 
   17113                         else if ( (synpred53_Java()) ) {s = 15;}
   17114 
   17115                         else if ( (synpred54_Java()) ) {s = 17;}
   17116 
   17117                         else if ( (true) ) {s = 19;}
   17118 
   17119 
   17120                         input.seek(index39_7);
   17121                         if ( s>=0 ) return s;
   17122                         break;
   17123                     case 7 :
   17124                         int LA39_8 = input.LA(1);
   17125 
   17126 
   17127                         int index39_8 = input.index();
   17128                         input.rewind();
   17129                         s = -1;
   17130                         if ( (synpred52_Java()) ) {s = 20;}
   17131 
   17132                         else if ( (synpred53_Java()) ) {s = 15;}
   17133 
   17134                         else if ( (synpred54_Java()) ) {s = 17;}
   17135 
   17136                         else if ( (true) ) {s = 19;}
   17137 
   17138 
   17139                         input.seek(index39_8);
   17140                         if ( s>=0 ) return s;
   17141                         break;
   17142                     case 8 :
   17143                         int LA39_9 = input.LA(1);
   17144 
   17145 
   17146                         int index39_9 = input.index();
   17147                         input.rewind();
   17148                         s = -1;
   17149                         if ( (synpred52_Java()) ) {s = 20;}
   17150 
   17151                         else if ( (synpred53_Java()) ) {s = 15;}
   17152 
   17153                         else if ( (synpred54_Java()) ) {s = 17;}
   17154 
   17155                         else if ( (true) ) {s = 19;}
   17156 
   17157 
   17158                         input.seek(index39_9);
   17159                         if ( s>=0 ) return s;
   17160                         break;
   17161                     case 9 :
   17162                         int LA39_10 = input.LA(1);
   17163 
   17164 
   17165                         int index39_10 = input.index();
   17166                         input.rewind();
   17167                         s = -1;
   17168                         if ( (synpred52_Java()) ) {s = 20;}
   17169 
   17170                         else if ( (synpred53_Java()) ) {s = 15;}
   17171 
   17172                         else if ( (synpred54_Java()) ) {s = 17;}
   17173 
   17174                         else if ( (true) ) {s = 19;}
   17175 
   17176 
   17177                         input.seek(index39_10);
   17178                         if ( s>=0 ) return s;
   17179                         break;
   17180                     case 10 :
   17181                         int LA39_11 = input.LA(1);
   17182 
   17183 
   17184                         int index39_11 = input.index();
   17185                         input.rewind();
   17186                         s = -1;
   17187                         if ( (synpred52_Java()) ) {s = 20;}
   17188 
   17189                         else if ( (synpred53_Java()) ) {s = 15;}
   17190 
   17191                         else if ( (synpred54_Java()) ) {s = 17;}
   17192 
   17193                         else if ( (true) ) {s = 19;}
   17194 
   17195 
   17196                         input.seek(index39_11);
   17197                         if ( s>=0 ) return s;
   17198                         break;
   17199                     case 11 :
   17200                         int LA39_12 = input.LA(1);
   17201 
   17202 
   17203                         int index39_12 = input.index();
   17204                         input.rewind();
   17205                         s = -1;
   17206                         if ( (synpred52_Java()) ) {s = 20;}
   17207 
   17208                         else if ( (synpred53_Java()) ) {s = 15;}
   17209 
   17210                         else if ( (synpred54_Java()) ) {s = 17;}
   17211 
   17212                         else if ( (true) ) {s = 19;}
   17213 
   17214 
   17215                         input.seek(index39_12);
   17216                         if ( s>=0 ) return s;
   17217                         break;
   17218                     case 12 :
   17219                         int LA39_13 = input.LA(1);
   17220 
   17221 
   17222                         int index39_13 = input.index();
   17223                         input.rewind();
   17224                         s = -1;
   17225                         if ( (synpred52_Java()) ) {s = 20;}
   17226 
   17227                         else if ( (synpred53_Java()) ) {s = 15;}
   17228 
   17229 
   17230                         input.seek(index39_13);
   17231                         if ( s>=0 ) return s;
   17232                         break;
   17233                     case 13 :
   17234                         int LA39_14 = input.LA(1);
   17235 
   17236 
   17237                         int index39_14 = input.index();
   17238                         input.rewind();
   17239                         s = -1;
   17240                         if ( (synpred52_Java()) ) {s = 20;}
   17241 
   17242                         else if ( (synpred53_Java()) ) {s = 15;}
   17243 
   17244 
   17245                         input.seek(index39_14);
   17246                         if ( s>=0 ) return s;
   17247                         break;
   17248             }
   17249             if (state.backtracking>0) {state.failed=true; return -1;}
   17250             NoViableAltException nvae =
   17251                 new NoViableAltException(getDescription(), 39, _s, input);
   17252             error(nvae);
   17253             throw nvae;
   17254         }
   17255     }
   17256     static final String DFA49_eotS =
   17257         "\22\uffff";
   17258     static final String DFA49_eofS =
   17259         "\22\uffff";
   17260     static final String DFA49_minS =
   17261         "\1\4\16\0\3\uffff";
   17262     static final String DFA49_maxS =
   17263         "\1\165\16\0\3\uffff";
   17264     static final String DFA49_acceptS =
   17265         "\17\uffff\1\2\1\uffff\1\1";
   17266     static final String DFA49_specialS =
   17267         "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
   17268         "\1\15\3\uffff}>";
   17269     static final String[] DFA49_transitionS = {
   17270             "\1\16\27\uffff\1\6\1\uffff\1\17\1\uffff\1\17\2\uffff\1\17\5"+
   17271             "\uffff\1\17\3\uffff\1\7\1\uffff\1\17\6\uffff\1\17\1\uffff\1"+
   17272             "\17\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\17\1\5\1\14\2\uffff\1"+
   17273             "\11\3\uffff\1\12\1\uffff\1\17\1\13\45\uffff\1\1\2\uffff\1\15",
   17274             "\1\uffff",
   17275             "\1\uffff",
   17276             "\1\uffff",
   17277             "\1\uffff",
   17278             "\1\uffff",
   17279             "\1\uffff",
   17280             "\1\uffff",
   17281             "\1\uffff",
   17282             "\1\uffff",
   17283             "\1\uffff",
   17284             "\1\uffff",
   17285             "\1\uffff",
   17286             "\1\uffff",
   17287             "\1\uffff",
   17288             "",
   17289             "",
   17290             ""
   17291     };
   17292 
   17293     static final short[] DFA49_eot = DFA.unpackEncodedString(DFA49_eotS);
   17294     static final short[] DFA49_eof = DFA.unpackEncodedString(DFA49_eofS);
   17295     static final char[] DFA49_min = DFA.unpackEncodedStringToUnsignedChars(DFA49_minS);
   17296     static final char[] DFA49_max = DFA.unpackEncodedStringToUnsignedChars(DFA49_maxS);
   17297     static final short[] DFA49_accept = DFA.unpackEncodedString(DFA49_acceptS);
   17298     static final short[] DFA49_special = DFA.unpackEncodedString(DFA49_specialS);
   17299     static final short[][] DFA49_transition;
   17300 
   17301     static {
   17302         int numStates = DFA49_transitionS.length;
   17303         DFA49_transition = new short[numStates][];
   17304         for (int i=0; i<numStates; i++) {
   17305             DFA49_transition[i] = DFA.unpackEncodedString(DFA49_transitionS[i]);
   17306         }
   17307     }
   17308 
   17309     class DFA49 extends DFA {
   17310 
   17311         public DFA49(BaseRecognizer recognizer) {
   17312             this.recognizer = recognizer;
   17313             this.decisionNumber = 49;
   17314             this.eot = DFA49_eot;
   17315             this.eof = DFA49_eof;
   17316             this.min = DFA49_min;
   17317             this.max = DFA49_max;
   17318             this.accept = DFA49_accept;
   17319             this.special = DFA49_special;
   17320             this.transition = DFA49_transition;
   17321         }
   17322         public String getDescription() {
   17323             return "510:1: methodDeclaration : ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) );";
   17324         }
   17325         public void error(NoViableAltException nvae) {
   17326             dbg.recognitionException(nvae);
   17327         }
   17328         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   17329             TokenStream input = (TokenStream)_input;
   17330 		int _s = s;
   17331             switch ( s ) {
   17332                     case 0 :
   17333                         int LA49_1 = input.LA(1);
   17334 
   17335 
   17336                         int index49_1 = input.index();
   17337                         input.rewind();
   17338                         s = -1;
   17339                         if ( (synpred59_Java()) ) {s = 17;}
   17340 
   17341                         else if ( (true) ) {s = 15;}
   17342 
   17343 
   17344                         input.seek(index49_1);
   17345                         if ( s>=0 ) return s;
   17346                         break;
   17347                     case 1 :
   17348                         int LA49_2 = input.LA(1);
   17349 
   17350 
   17351                         int index49_2 = input.index();
   17352                         input.rewind();
   17353                         s = -1;
   17354                         if ( (synpred59_Java()) ) {s = 17;}
   17355 
   17356                         else if ( (true) ) {s = 15;}
   17357 
   17358 
   17359                         input.seek(index49_2);
   17360                         if ( s>=0 ) return s;
   17361                         break;
   17362                     case 2 :
   17363                         int LA49_3 = input.LA(1);
   17364 
   17365 
   17366                         int index49_3 = input.index();
   17367                         input.rewind();
   17368                         s = -1;
   17369                         if ( (synpred59_Java()) ) {s = 17;}
   17370 
   17371                         else if ( (true) ) {s = 15;}
   17372 
   17373 
   17374                         input.seek(index49_3);
   17375                         if ( s>=0 ) return s;
   17376                         break;
   17377                     case 3 :
   17378                         int LA49_4 = input.LA(1);
   17379 
   17380 
   17381                         int index49_4 = input.index();
   17382                         input.rewind();
   17383                         s = -1;
   17384                         if ( (synpred59_Java()) ) {s = 17;}
   17385 
   17386                         else if ( (true) ) {s = 15;}
   17387 
   17388 
   17389                         input.seek(index49_4);
   17390                         if ( s>=0 ) return s;
   17391                         break;
   17392                     case 4 :
   17393                         int LA49_5 = input.LA(1);
   17394 
   17395 
   17396                         int index49_5 = input.index();
   17397                         input.rewind();
   17398                         s = -1;
   17399                         if ( (synpred59_Java()) ) {s = 17;}
   17400 
   17401                         else if ( (true) ) {s = 15;}
   17402 
   17403 
   17404                         input.seek(index49_5);
   17405                         if ( s>=0 ) return s;
   17406                         break;
   17407                     case 5 :
   17408                         int LA49_6 = input.LA(1);
   17409 
   17410 
   17411                         int index49_6 = input.index();
   17412                         input.rewind();
   17413                         s = -1;
   17414                         if ( (synpred59_Java()) ) {s = 17;}
   17415 
   17416                         else if ( (true) ) {s = 15;}
   17417 
   17418 
   17419                         input.seek(index49_6);
   17420                         if ( s>=0 ) return s;
   17421                         break;
   17422                     case 6 :
   17423                         int LA49_7 = input.LA(1);
   17424 
   17425 
   17426                         int index49_7 = input.index();
   17427                         input.rewind();
   17428                         s = -1;
   17429                         if ( (synpred59_Java()) ) {s = 17;}
   17430 
   17431                         else if ( (true) ) {s = 15;}
   17432 
   17433 
   17434                         input.seek(index49_7);
   17435                         if ( s>=0 ) return s;
   17436                         break;
   17437                     case 7 :
   17438                         int LA49_8 = input.LA(1);
   17439 
   17440 
   17441                         int index49_8 = input.index();
   17442                         input.rewind();
   17443                         s = -1;
   17444                         if ( (synpred59_Java()) ) {s = 17;}
   17445 
   17446                         else if ( (true) ) {s = 15;}
   17447 
   17448 
   17449                         input.seek(index49_8);
   17450                         if ( s>=0 ) return s;
   17451                         break;
   17452                     case 8 :
   17453                         int LA49_9 = input.LA(1);
   17454 
   17455 
   17456                         int index49_9 = input.index();
   17457                         input.rewind();
   17458                         s = -1;
   17459                         if ( (synpred59_Java()) ) {s = 17;}
   17460 
   17461                         else if ( (true) ) {s = 15;}
   17462 
   17463 
   17464                         input.seek(index49_9);
   17465                         if ( s>=0 ) return s;
   17466                         break;
   17467                     case 9 :
   17468                         int LA49_10 = input.LA(1);
   17469 
   17470 
   17471                         int index49_10 = input.index();
   17472                         input.rewind();
   17473                         s = -1;
   17474                         if ( (synpred59_Java()) ) {s = 17;}
   17475 
   17476                         else if ( (true) ) {s = 15;}
   17477 
   17478 
   17479                         input.seek(index49_10);
   17480                         if ( s>=0 ) return s;
   17481                         break;
   17482                     case 10 :
   17483                         int LA49_11 = input.LA(1);
   17484 
   17485 
   17486                         int index49_11 = input.index();
   17487                         input.rewind();
   17488                         s = -1;
   17489                         if ( (synpred59_Java()) ) {s = 17;}
   17490 
   17491                         else if ( (true) ) {s = 15;}
   17492 
   17493 
   17494                         input.seek(index49_11);
   17495                         if ( s>=0 ) return s;
   17496                         break;
   17497                     case 11 :
   17498                         int LA49_12 = input.LA(1);
   17499 
   17500 
   17501                         int index49_12 = input.index();
   17502                         input.rewind();
   17503                         s = -1;
   17504                         if ( (synpred59_Java()) ) {s = 17;}
   17505 
   17506                         else if ( (true) ) {s = 15;}
   17507 
   17508 
   17509                         input.seek(index49_12);
   17510                         if ( s>=0 ) return s;
   17511                         break;
   17512                     case 12 :
   17513                         int LA49_13 = input.LA(1);
   17514 
   17515 
   17516                         int index49_13 = input.index();
   17517                         input.rewind();
   17518                         s = -1;
   17519                         if ( (synpred59_Java()) ) {s = 17;}
   17520 
   17521                         else if ( (true) ) {s = 15;}
   17522 
   17523 
   17524                         input.seek(index49_13);
   17525                         if ( s>=0 ) return s;
   17526                         break;
   17527                     case 13 :
   17528                         int LA49_14 = input.LA(1);
   17529 
   17530 
   17531                         int index49_14 = input.index();
   17532                         input.rewind();
   17533                         s = -1;
   17534                         if ( (synpred59_Java()) ) {s = 17;}
   17535 
   17536                         else if ( (true) ) {s = 15;}
   17537 
   17538 
   17539                         input.seek(index49_14);
   17540                         if ( s>=0 ) return s;
   17541                         break;
   17542             }
   17543             if (state.backtracking>0) {state.failed=true; return -1;}
   17544             NoViableAltException nvae =
   17545                 new NoViableAltException(getDescription(), 49, _s, input);
   17546             error(nvae);
   17547             throw nvae;
   17548         }
   17549     }
   17550     static final String DFA42_eotS =
   17551         "\55\uffff";
   17552     static final String DFA42_eofS =
   17553         "\55\uffff";
   17554     static final String DFA42_minS =
   17555         "\1\4\1\uffff\10\0\43\uffff";
   17556     static final String DFA42_maxS =
   17557         "\1\165\1\uffff\10\0\43\uffff";
   17558     static final String DFA42_acceptS =
   17559         "\1\uffff\1\1\10\uffff\1\2\42\uffff";
   17560     static final String DFA42_specialS =
   17561         "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\43\uffff}>";
   17562     static final String[] DFA42_transitionS = {
   17563             "\1\5\11\6\16\uffff\2\12\1\10\1\12\1\10\2\uffff\1\10\1\12\1\uffff"+
   17564             "\1\12\1\uffff\1\12\1\10\1\uffff\1\12\1\uffff\1\12\1\uffff\1"+
   17565             "\10\1\12\1\uffff\1\12\3\uffff\1\10\1\12\1\10\1\12\1\7\1\uffff"+
   17566             "\4\12\1\10\2\12\1\4\2\12\1\2\1\12\1\uffff\2\12\1\11\2\12\1\3"+
   17567             "\1\uffff\2\12\2\uffff\1\12\4\uffff\2\12\5\uffff\4\12\16\uffff"+
   17568             "\1\12\2\uffff\1\1",
   17569             "",
   17570             "\1\uffff",
   17571             "\1\uffff",
   17572             "\1\uffff",
   17573             "\1\uffff",
   17574             "\1\uffff",
   17575             "\1\uffff",
   17576             "\1\uffff",
   17577             "\1\uffff",
   17578             "",
   17579             "",
   17580             "",
   17581             "",
   17582             "",
   17583             "",
   17584             "",
   17585             "",
   17586             "",
   17587             "",
   17588             "",
   17589             "",
   17590             "",
   17591             "",
   17592             "",
   17593             "",
   17594             "",
   17595             "",
   17596             "",
   17597             "",
   17598             "",
   17599             "",
   17600             "",
   17601             "",
   17602             "",
   17603             "",
   17604             "",
   17605             "",
   17606             "",
   17607             "",
   17608             "",
   17609             "",
   17610             "",
   17611             "",
   17612             ""
   17613     };
   17614 
   17615     static final short[] DFA42_eot = DFA.unpackEncodedString(DFA42_eotS);
   17616     static final short[] DFA42_eof = DFA.unpackEncodedString(DFA42_eofS);
   17617     static final char[] DFA42_min = DFA.unpackEncodedStringToUnsignedChars(DFA42_minS);
   17618     static final char[] DFA42_max = DFA.unpackEncodedStringToUnsignedChars(DFA42_maxS);
   17619     static final short[] DFA42_accept = DFA.unpackEncodedString(DFA42_acceptS);
   17620     static final short[] DFA42_special = DFA.unpackEncodedString(DFA42_specialS);
   17621     static final short[][] DFA42_transition;
   17622 
   17623     static {
   17624         int numStates = DFA42_transitionS.length;
   17625         DFA42_transition = new short[numStates][];
   17626         for (int i=0; i<numStates; i++) {
   17627             DFA42_transition[i] = DFA.unpackEncodedString(DFA42_transitionS[i]);
   17628         }
   17629     }
   17630 
   17631     class DFA42 extends DFA {
   17632 
   17633         public DFA42(BaseRecognizer recognizer) {
   17634             this.recognizer = recognizer;
   17635             this.decisionNumber = 42;
   17636             this.eot = DFA42_eot;
   17637             this.eof = DFA42_eof;
   17638             this.min = DFA42_min;
   17639             this.max = DFA42_max;
   17640             this.accept = DFA42_accept;
   17641             this.special = DFA42_special;
   17642             this.transition = DFA42_transition;
   17643         }
   17644         public String getDescription() {
   17645             return "521:9: ( explicitConstructorInvocation )?";
   17646         }
   17647         public void error(NoViableAltException nvae) {
   17648             dbg.recognitionException(nvae);
   17649         }
   17650         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   17651             TokenStream input = (TokenStream)_input;
   17652 		int _s = s;
   17653             switch ( s ) {
   17654                     case 0 :
   17655                         int LA42_2 = input.LA(1);
   17656 
   17657 
   17658                         int index42_2 = input.index();
   17659                         input.rewind();
   17660                         s = -1;
   17661                         if ( (synpred57_Java()) ) {s = 1;}
   17662 
   17663                         else if ( (true) ) {s = 10;}
   17664 
   17665 
   17666                         input.seek(index42_2);
   17667                         if ( s>=0 ) return s;
   17668                         break;
   17669                     case 1 :
   17670                         int LA42_3 = input.LA(1);
   17671 
   17672 
   17673                         int index42_3 = input.index();
   17674                         input.rewind();
   17675                         s = -1;
   17676                         if ( (synpred57_Java()) ) {s = 1;}
   17677 
   17678                         else if ( (true) ) {s = 10;}
   17679 
   17680 
   17681                         input.seek(index42_3);
   17682                         if ( s>=0 ) return s;
   17683                         break;
   17684                     case 2 :
   17685                         int LA42_4 = input.LA(1);
   17686 
   17687 
   17688                         int index42_4 = input.index();
   17689                         input.rewind();
   17690                         s = -1;
   17691                         if ( (synpred57_Java()) ) {s = 1;}
   17692 
   17693                         else if ( (true) ) {s = 10;}
   17694 
   17695 
   17696                         input.seek(index42_4);
   17697                         if ( s>=0 ) return s;
   17698                         break;
   17699                     case 3 :
   17700                         int LA42_5 = input.LA(1);
   17701 
   17702 
   17703                         int index42_5 = input.index();
   17704                         input.rewind();
   17705                         s = -1;
   17706                         if ( (synpred57_Java()) ) {s = 1;}
   17707 
   17708                         else if ( (true) ) {s = 10;}
   17709 
   17710 
   17711                         input.seek(index42_5);
   17712                         if ( s>=0 ) return s;
   17713                         break;
   17714                     case 4 :
   17715                         int LA42_6 = input.LA(1);
   17716 
   17717 
   17718                         int index42_6 = input.index();
   17719                         input.rewind();
   17720                         s = -1;
   17721                         if ( (synpred57_Java()) ) {s = 1;}
   17722 
   17723                         else if ( (true) ) {s = 10;}
   17724 
   17725 
   17726                         input.seek(index42_6);
   17727                         if ( s>=0 ) return s;
   17728                         break;
   17729                     case 5 :
   17730                         int LA42_7 = input.LA(1);
   17731 
   17732 
   17733                         int index42_7 = input.index();
   17734                         input.rewind();
   17735                         s = -1;
   17736                         if ( (synpred57_Java()) ) {s = 1;}
   17737 
   17738                         else if ( (true) ) {s = 10;}
   17739 
   17740 
   17741                         input.seek(index42_7);
   17742                         if ( s>=0 ) return s;
   17743                         break;
   17744                     case 6 :
   17745                         int LA42_8 = input.LA(1);
   17746 
   17747 
   17748                         int index42_8 = input.index();
   17749                         input.rewind();
   17750                         s = -1;
   17751                         if ( (synpred57_Java()) ) {s = 1;}
   17752 
   17753                         else if ( (true) ) {s = 10;}
   17754 
   17755 
   17756                         input.seek(index42_8);
   17757                         if ( s>=0 ) return s;
   17758                         break;
   17759                     case 7 :
   17760                         int LA42_9 = input.LA(1);
   17761 
   17762 
   17763                         int index42_9 = input.index();
   17764                         input.rewind();
   17765                         s = -1;
   17766                         if ( (synpred57_Java()) ) {s = 1;}
   17767 
   17768                         else if ( (true) ) {s = 10;}
   17769 
   17770 
   17771                         input.seek(index42_9);
   17772                         if ( s>=0 ) return s;
   17773                         break;
   17774             }
   17775             if (state.backtracking>0) {state.failed=true; return -1;}
   17776             NoViableAltException nvae =
   17777                 new NoViableAltException(getDescription(), 42, _s, input);
   17778             error(nvae);
   17779             throw nvae;
   17780         }
   17781     }
   17782     static final String DFA53_eotS =
   17783         "\26\uffff";
   17784     static final String DFA53_eofS =
   17785         "\26\uffff";
   17786     static final String DFA53_minS =
   17787         "\1\4\16\0\7\uffff";
   17788     static final String DFA53_maxS =
   17789         "\1\165\16\0\7\uffff";
   17790     static final String DFA53_acceptS =
   17791         "\17\uffff\1\2\1\uffff\1\3\1\4\1\uffff\1\5\1\1";
   17792     static final String DFA53_specialS =
   17793         "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
   17794         "\1\15\7\uffff}>";
   17795     static final String[] DFA53_transitionS = {
   17796             "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+
   17797             "\22\4\uffff\1\16\1\uffff\1\22\1\uffff\1\7\1\uffff\1\16\6\uffff"+
   17798             "\1\16\1\21\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+
   17799             "\14\2\uffff\1\11\3\uffff\1\12\1\uffff\1\17\1\13\7\uffff\1\24"+
   17800             "\35\uffff\1\1\2\uffff\1\17",
   17801             "\1\uffff",
   17802             "\1\uffff",
   17803             "\1\uffff",
   17804             "\1\uffff",
   17805             "\1\uffff",
   17806             "\1\uffff",
   17807             "\1\uffff",
   17808             "\1\uffff",
   17809             "\1\uffff",
   17810             "\1\uffff",
   17811             "\1\uffff",
   17812             "\1\uffff",
   17813             "\1\uffff",
   17814             "\1\uffff",
   17815             "",
   17816             "",
   17817             "",
   17818             "",
   17819             "",
   17820             "",
   17821             ""
   17822     };
   17823 
   17824     static final short[] DFA53_eot = DFA.unpackEncodedString(DFA53_eotS);
   17825     static final short[] DFA53_eof = DFA.unpackEncodedString(DFA53_eofS);
   17826     static final char[] DFA53_min = DFA.unpackEncodedStringToUnsignedChars(DFA53_minS);
   17827     static final char[] DFA53_max = DFA.unpackEncodedStringToUnsignedChars(DFA53_maxS);
   17828     static final short[] DFA53_accept = DFA.unpackEncodedString(DFA53_acceptS);
   17829     static final short[] DFA53_special = DFA.unpackEncodedString(DFA53_specialS);
   17830     static final short[][] DFA53_transition;
   17831 
   17832     static {
   17833         int numStates = DFA53_transitionS.length;
   17834         DFA53_transition = new short[numStates][];
   17835         for (int i=0; i<numStates; i++) {
   17836             DFA53_transition[i] = DFA.unpackEncodedString(DFA53_transitionS[i]);
   17837         }
   17838     }
   17839 
   17840     class DFA53 extends DFA {
   17841 
   17842         public DFA53(BaseRecognizer recognizer) {
   17843             this.recognizer = recognizer;
   17844             this.decisionNumber = 53;
   17845             this.eot = DFA53_eot;
   17846             this.eof = DFA53_eof;
   17847             this.min = DFA53_min;
   17848             this.max = DFA53_max;
   17849             this.accept = DFA53_accept;
   17850             this.special = DFA53_special;
   17851             this.transition = DFA53_transition;
   17852         }
   17853         public String getDescription() {
   17854             return "562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' );";
   17855         }
   17856         public void error(NoViableAltException nvae) {
   17857             dbg.recognitionException(nvae);
   17858         }
   17859         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   17860             TokenStream input = (TokenStream)_input;
   17861 		int _s = s;
   17862             switch ( s ) {
   17863                     case 0 :
   17864                         int LA53_1 = input.LA(1);
   17865 
   17866 
   17867                         int index53_1 = input.index();
   17868                         input.rewind();
   17869                         s = -1;
   17870                         if ( (synpred68_Java()) ) {s = 21;}
   17871 
   17872                         else if ( (synpred69_Java()) ) {s = 15;}
   17873 
   17874                         else if ( (synpred70_Java()) ) {s = 17;}
   17875 
   17876                         else if ( (synpred71_Java()) ) {s = 18;}
   17877 
   17878 
   17879                         input.seek(index53_1);
   17880                         if ( s>=0 ) return s;
   17881                         break;
   17882                     case 1 :
   17883                         int LA53_2 = input.LA(1);
   17884 
   17885 
   17886                         int index53_2 = input.index();
   17887                         input.rewind();
   17888                         s = -1;
   17889                         if ( (synpred68_Java()) ) {s = 21;}
   17890 
   17891                         else if ( (synpred69_Java()) ) {s = 15;}
   17892 
   17893                         else if ( (synpred70_Java()) ) {s = 17;}
   17894 
   17895                         else if ( (synpred71_Java()) ) {s = 18;}
   17896 
   17897 
   17898                         input.seek(index53_2);
   17899                         if ( s>=0 ) return s;
   17900                         break;
   17901                     case 2 :
   17902                         int LA53_3 = input.LA(1);
   17903 
   17904 
   17905                         int index53_3 = input.index();
   17906                         input.rewind();
   17907                         s = -1;
   17908                         if ( (synpred68_Java()) ) {s = 21;}
   17909 
   17910                         else if ( (synpred69_Java()) ) {s = 15;}
   17911 
   17912                         else if ( (synpred70_Java()) ) {s = 17;}
   17913 
   17914                         else if ( (synpred71_Java()) ) {s = 18;}
   17915 
   17916 
   17917                         input.seek(index53_3);
   17918                         if ( s>=0 ) return s;
   17919                         break;
   17920                     case 3 :
   17921                         int LA53_4 = input.LA(1);
   17922 
   17923 
   17924                         int index53_4 = input.index();
   17925                         input.rewind();
   17926                         s = -1;
   17927                         if ( (synpred68_Java()) ) {s = 21;}
   17928 
   17929                         else if ( (synpred69_Java()) ) {s = 15;}
   17930 
   17931                         else if ( (synpred70_Java()) ) {s = 17;}
   17932 
   17933                         else if ( (synpred71_Java()) ) {s = 18;}
   17934 
   17935 
   17936                         input.seek(index53_4);
   17937                         if ( s>=0 ) return s;
   17938                         break;
   17939                     case 4 :
   17940                         int LA53_5 = input.LA(1);
   17941 
   17942 
   17943                         int index53_5 = input.index();
   17944                         input.rewind();
   17945                         s = -1;
   17946                         if ( (synpred68_Java()) ) {s = 21;}
   17947 
   17948                         else if ( (synpred69_Java()) ) {s = 15;}
   17949 
   17950                         else if ( (synpred70_Java()) ) {s = 17;}
   17951 
   17952                         else if ( (synpred71_Java()) ) {s = 18;}
   17953 
   17954 
   17955                         input.seek(index53_5);
   17956                         if ( s>=0 ) return s;
   17957                         break;
   17958                     case 5 :
   17959                         int LA53_6 = input.LA(1);
   17960 
   17961 
   17962                         int index53_6 = input.index();
   17963                         input.rewind();
   17964                         s = -1;
   17965                         if ( (synpred68_Java()) ) {s = 21;}
   17966 
   17967                         else if ( (synpred69_Java()) ) {s = 15;}
   17968 
   17969                         else if ( (synpred70_Java()) ) {s = 17;}
   17970 
   17971                         else if ( (synpred71_Java()) ) {s = 18;}
   17972 
   17973 
   17974                         input.seek(index53_6);
   17975                         if ( s>=0 ) return s;
   17976                         break;
   17977                     case 6 :
   17978                         int LA53_7 = input.LA(1);
   17979 
   17980 
   17981                         int index53_7 = input.index();
   17982                         input.rewind();
   17983                         s = -1;
   17984                         if ( (synpred68_Java()) ) {s = 21;}
   17985 
   17986                         else if ( (synpred69_Java()) ) {s = 15;}
   17987 
   17988                         else if ( (synpred70_Java()) ) {s = 17;}
   17989 
   17990                         else if ( (synpred71_Java()) ) {s = 18;}
   17991 
   17992 
   17993                         input.seek(index53_7);
   17994                         if ( s>=0 ) return s;
   17995                         break;
   17996                     case 7 :
   17997                         int LA53_8 = input.LA(1);
   17998 
   17999 
   18000                         int index53_8 = input.index();
   18001                         input.rewind();
   18002                         s = -1;
   18003                         if ( (synpred68_Java()) ) {s = 21;}
   18004 
   18005                         else if ( (synpred69_Java()) ) {s = 15;}
   18006 
   18007                         else if ( (synpred70_Java()) ) {s = 17;}
   18008 
   18009                         else if ( (synpred71_Java()) ) {s = 18;}
   18010 
   18011 
   18012                         input.seek(index53_8);
   18013                         if ( s>=0 ) return s;
   18014                         break;
   18015                     case 8 :
   18016                         int LA53_9 = input.LA(1);
   18017 
   18018 
   18019                         int index53_9 = input.index();
   18020                         input.rewind();
   18021                         s = -1;
   18022                         if ( (synpred68_Java()) ) {s = 21;}
   18023 
   18024                         else if ( (synpred69_Java()) ) {s = 15;}
   18025 
   18026                         else if ( (synpred70_Java()) ) {s = 17;}
   18027 
   18028                         else if ( (synpred71_Java()) ) {s = 18;}
   18029 
   18030 
   18031                         input.seek(index53_9);
   18032                         if ( s>=0 ) return s;
   18033                         break;
   18034                     case 9 :
   18035                         int LA53_10 = input.LA(1);
   18036 
   18037 
   18038                         int index53_10 = input.index();
   18039                         input.rewind();
   18040                         s = -1;
   18041                         if ( (synpred68_Java()) ) {s = 21;}
   18042 
   18043                         else if ( (synpred69_Java()) ) {s = 15;}
   18044 
   18045                         else if ( (synpred70_Java()) ) {s = 17;}
   18046 
   18047                         else if ( (synpred71_Java()) ) {s = 18;}
   18048 
   18049 
   18050                         input.seek(index53_10);
   18051                         if ( s>=0 ) return s;
   18052                         break;
   18053                     case 10 :
   18054                         int LA53_11 = input.LA(1);
   18055 
   18056 
   18057                         int index53_11 = input.index();
   18058                         input.rewind();
   18059                         s = -1;
   18060                         if ( (synpred68_Java()) ) {s = 21;}
   18061 
   18062                         else if ( (synpred69_Java()) ) {s = 15;}
   18063 
   18064                         else if ( (synpred70_Java()) ) {s = 17;}
   18065 
   18066                         else if ( (synpred71_Java()) ) {s = 18;}
   18067 
   18068 
   18069                         input.seek(index53_11);
   18070                         if ( s>=0 ) return s;
   18071                         break;
   18072                     case 11 :
   18073                         int LA53_12 = input.LA(1);
   18074 
   18075 
   18076                         int index53_12 = input.index();
   18077                         input.rewind();
   18078                         s = -1;
   18079                         if ( (synpred68_Java()) ) {s = 21;}
   18080 
   18081                         else if ( (synpred69_Java()) ) {s = 15;}
   18082 
   18083                         else if ( (synpred70_Java()) ) {s = 17;}
   18084 
   18085                         else if ( (synpred71_Java()) ) {s = 18;}
   18086 
   18087 
   18088                         input.seek(index53_12);
   18089                         if ( s>=0 ) return s;
   18090                         break;
   18091                     case 12 :
   18092                         int LA53_13 = input.LA(1);
   18093 
   18094 
   18095                         int index53_13 = input.index();
   18096                         input.rewind();
   18097                         s = -1;
   18098                         if ( (synpred68_Java()) ) {s = 21;}
   18099 
   18100                         else if ( (synpred69_Java()) ) {s = 15;}
   18101 
   18102 
   18103                         input.seek(index53_13);
   18104                         if ( s>=0 ) return s;
   18105                         break;
   18106                     case 13 :
   18107                         int LA53_14 = input.LA(1);
   18108 
   18109 
   18110                         int index53_14 = input.index();
   18111                         input.rewind();
   18112                         s = -1;
   18113                         if ( (synpred68_Java()) ) {s = 21;}
   18114 
   18115                         else if ( (synpred69_Java()) ) {s = 15;}
   18116 
   18117 
   18118                         input.seek(index53_14);
   18119                         if ( s>=0 ) return s;
   18120                         break;
   18121             }
   18122             if (state.backtracking>0) {state.failed=true; return -1;}
   18123             NoViableAltException nvae =
   18124                 new NoViableAltException(getDescription(), 53, _s, input);
   18125             error(nvae);
   18126             throw nvae;
   18127         }
   18128     }
   18129     static final String DFA76_eotS =
   18130         "\12\uffff";
   18131     static final String DFA76_eofS =
   18132         "\12\uffff";
   18133     static final String DFA76_minS =
   18134         "\1\4\1\uffff\1\0\1\uffff\1\0\5\uffff";
   18135     static final String DFA76_maxS =
   18136         "\1\165\1\uffff\1\0\1\uffff\1\0\5\uffff";
   18137     static final String DFA76_acceptS =
   18138         "\1\uffff\1\1\1\uffff\1\2\6\uffff";
   18139     static final String DFA76_specialS =
   18140         "\2\uffff\1\0\1\uffff\1\1\5\uffff}>";
   18141     static final String[] DFA76_transitionS = {
   18142             "\12\3\20\uffff\1\3\1\uffff\1\3\2\uffff\1\3\5\uffff\1\3\5\uffff"+
   18143             "\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\5\uffff\1\3\2\uffff"+
   18144             "\1\4\2\uffff\1\2\4\uffff\1\3\2\uffff\1\3\46\uffff\1\1",
   18145             "",
   18146             "\1\uffff",
   18147             "",
   18148             "\1\uffff",
   18149             "",
   18150             "",
   18151             "",
   18152             "",
   18153             ""
   18154     };
   18155 
   18156     static final short[] DFA76_eot = DFA.unpackEncodedString(DFA76_eotS);
   18157     static final short[] DFA76_eof = DFA.unpackEncodedString(DFA76_eofS);
   18158     static final char[] DFA76_min = DFA.unpackEncodedStringToUnsignedChars(DFA76_minS);
   18159     static final char[] DFA76_max = DFA.unpackEncodedStringToUnsignedChars(DFA76_maxS);
   18160     static final short[] DFA76_accept = DFA.unpackEncodedString(DFA76_acceptS);
   18161     static final short[] DFA76_special = DFA.unpackEncodedString(DFA76_specialS);
   18162     static final short[][] DFA76_transition;
   18163 
   18164     static {
   18165         int numStates = DFA76_transitionS.length;
   18166         DFA76_transition = new short[numStates][];
   18167         for (int i=0; i<numStates; i++) {
   18168             DFA76_transition[i] = DFA.unpackEncodedString(DFA76_transitionS[i]);
   18169         }
   18170     }
   18171 
   18172     class DFA76 extends DFA {
   18173 
   18174         public DFA76(BaseRecognizer recognizer) {
   18175             this.recognizer = recognizer;
   18176             this.decisionNumber = 76;
   18177             this.eot = DFA76_eot;
   18178             this.eof = DFA76_eof;
   18179             this.min = DFA76_min;
   18180             this.max = DFA76_max;
   18181             this.accept = DFA76_accept;
   18182             this.special = DFA76_special;
   18183             this.transition = DFA76_transition;
   18184         }
   18185         public String getDescription() {
   18186             return "688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' );";
   18187         }
   18188         public void error(NoViableAltException nvae) {
   18189             dbg.recognitionException(nvae);
   18190         }
   18191         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   18192             TokenStream input = (TokenStream)_input;
   18193 		int _s = s;
   18194             switch ( s ) {
   18195                     case 0 :
   18196                         int LA76_2 = input.LA(1);
   18197 
   18198 
   18199                         int index76_2 = input.index();
   18200                         input.rewind();
   18201                         s = -1;
   18202                         if ( (synpred103_Java()) ) {s = 1;}
   18203 
   18204                         else if ( (true) ) {s = 3;}
   18205 
   18206 
   18207                         input.seek(index76_2);
   18208                         if ( s>=0 ) return s;
   18209                         break;
   18210                     case 1 :
   18211                         int LA76_4 = input.LA(1);
   18212 
   18213 
   18214                         int index76_4 = input.index();
   18215                         input.rewind();
   18216                         s = -1;
   18217                         if ( (synpred103_Java()) ) {s = 1;}
   18218 
   18219                         else if ( (true) ) {s = 3;}
   18220 
   18221 
   18222                         input.seek(index76_4);
   18223                         if ( s>=0 ) return s;
   18224                         break;
   18225             }
   18226             if (state.backtracking>0) {state.failed=true; return -1;}
   18227             NoViableAltException nvae =
   18228                 new NoViableAltException(getDescription(), 76, _s, input);
   18229             error(nvae);
   18230             throw nvae;
   18231         }
   18232     }
   18233     static final String DFA87_eotS =
   18234         "\26\uffff";
   18235     static final String DFA87_eofS =
   18236         "\26\uffff";
   18237     static final String DFA87_minS =
   18238         "\1\4\16\0\7\uffff";
   18239     static final String DFA87_maxS =
   18240         "\1\162\16\0\7\uffff";
   18241     static final String DFA87_acceptS =
   18242         "\17\uffff\1\3\1\4\1\5\1\7\1\1\1\2\1\6";
   18243     static final String DFA87_specialS =
   18244         "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
   18245         "\1\15\7\uffff}>";
   18246     static final String[] DFA87_transitionS = {
   18247             "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+
   18248             "\17\4\uffff\1\16\1\uffff\1\21\1\uffff\1\7\1\uffff\1\16\6\uffff"+
   18249             "\1\16\1\20\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+
   18250             "\14\2\uffff\1\11\3\uffff\1\12\2\uffff\1\13\7\uffff\1\22\35\uffff"+
   18251             "\1\1",
   18252             "\1\uffff",
   18253             "\1\uffff",
   18254             "\1\uffff",
   18255             "\1\uffff",
   18256             "\1\uffff",
   18257             "\1\uffff",
   18258             "\1\uffff",
   18259             "\1\uffff",
   18260             "\1\uffff",
   18261             "\1\uffff",
   18262             "\1\uffff",
   18263             "\1\uffff",
   18264             "\1\uffff",
   18265             "\1\uffff",
   18266             "",
   18267             "",
   18268             "",
   18269             "",
   18270             "",
   18271             "",
   18272             ""
   18273     };
   18274 
   18275     static final short[] DFA87_eot = DFA.unpackEncodedString(DFA87_eotS);
   18276     static final short[] DFA87_eof = DFA.unpackEncodedString(DFA87_eofS);
   18277     static final char[] DFA87_min = DFA.unpackEncodedStringToUnsignedChars(DFA87_minS);
   18278     static final char[] DFA87_max = DFA.unpackEncodedStringToUnsignedChars(DFA87_maxS);
   18279     static final short[] DFA87_accept = DFA.unpackEncodedString(DFA87_acceptS);
   18280     static final short[] DFA87_special = DFA.unpackEncodedString(DFA87_specialS);
   18281     static final short[][] DFA87_transition;
   18282 
   18283     static {
   18284         int numStates = DFA87_transitionS.length;
   18285         DFA87_transition = new short[numStates][];
   18286         for (int i=0; i<numStates; i++) {
   18287             DFA87_transition[i] = DFA.unpackEncodedString(DFA87_transitionS[i]);
   18288         }
   18289     }
   18290 
   18291     class DFA87 extends DFA {
   18292 
   18293         public DFA87(BaseRecognizer recognizer) {
   18294             this.recognizer = recognizer;
   18295             this.decisionNumber = 87;
   18296             this.eot = DFA87_eot;
   18297             this.eof = DFA87_eof;
   18298             this.min = DFA87_min;
   18299             this.max = DFA87_max;
   18300             this.accept = DFA87_accept;
   18301             this.special = DFA87_special;
   18302             this.transition = DFA87_transition;
   18303         }
   18304         public String getDescription() {
   18305             return "772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' );";
   18306         }
   18307         public void error(NoViableAltException nvae) {
   18308             dbg.recognitionException(nvae);
   18309         }
   18310         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   18311             TokenStream input = (TokenStream)_input;
   18312 		int _s = s;
   18313             switch ( s ) {
   18314                     case 0 :
   18315                         int LA87_1 = input.LA(1);
   18316 
   18317 
   18318                         int index87_1 = input.index();
   18319                         input.rewind();
   18320                         s = -1;
   18321                         if ( (synpred117_Java()) ) {s = 19;}
   18322 
   18323                         else if ( (synpred118_Java()) ) {s = 20;}
   18324 
   18325                         else if ( (synpred119_Java()) ) {s = 15;}
   18326 
   18327                         else if ( (synpred120_Java()) ) {s = 16;}
   18328 
   18329                         else if ( (synpred121_Java()) ) {s = 17;}
   18330 
   18331                         else if ( (synpred122_Java()) ) {s = 21;}
   18332 
   18333 
   18334                         input.seek(index87_1);
   18335                         if ( s>=0 ) return s;
   18336                         break;
   18337                     case 1 :
   18338                         int LA87_2 = input.LA(1);
   18339 
   18340 
   18341                         int index87_2 = input.index();
   18342                         input.rewind();
   18343                         s = -1;
   18344                         if ( (synpred117_Java()) ) {s = 19;}
   18345 
   18346                         else if ( (synpred118_Java()) ) {s = 20;}
   18347 
   18348                         else if ( (synpred119_Java()) ) {s = 15;}
   18349 
   18350                         else if ( (synpred120_Java()) ) {s = 16;}
   18351 
   18352                         else if ( (synpred121_Java()) ) {s = 17;}
   18353 
   18354                         else if ( (synpred122_Java()) ) {s = 21;}
   18355 
   18356 
   18357                         input.seek(index87_2);
   18358                         if ( s>=0 ) return s;
   18359                         break;
   18360                     case 2 :
   18361                         int LA87_3 = input.LA(1);
   18362 
   18363 
   18364                         int index87_3 = input.index();
   18365                         input.rewind();
   18366                         s = -1;
   18367                         if ( (synpred117_Java()) ) {s = 19;}
   18368 
   18369                         else if ( (synpred118_Java()) ) {s = 20;}
   18370 
   18371                         else if ( (synpred119_Java()) ) {s = 15;}
   18372 
   18373                         else if ( (synpred120_Java()) ) {s = 16;}
   18374 
   18375                         else if ( (synpred121_Java()) ) {s = 17;}
   18376 
   18377                         else if ( (synpred122_Java()) ) {s = 21;}
   18378 
   18379 
   18380                         input.seek(index87_3);
   18381                         if ( s>=0 ) return s;
   18382                         break;
   18383                     case 3 :
   18384                         int LA87_4 = input.LA(1);
   18385 
   18386 
   18387                         int index87_4 = input.index();
   18388                         input.rewind();
   18389                         s = -1;
   18390                         if ( (synpred117_Java()) ) {s = 19;}
   18391 
   18392                         else if ( (synpred118_Java()) ) {s = 20;}
   18393 
   18394                         else if ( (synpred119_Java()) ) {s = 15;}
   18395 
   18396                         else if ( (synpred120_Java()) ) {s = 16;}
   18397 
   18398                         else if ( (synpred121_Java()) ) {s = 17;}
   18399 
   18400                         else if ( (synpred122_Java()) ) {s = 21;}
   18401 
   18402 
   18403                         input.seek(index87_4);
   18404                         if ( s>=0 ) return s;
   18405                         break;
   18406                     case 4 :
   18407                         int LA87_5 = input.LA(1);
   18408 
   18409 
   18410                         int index87_5 = input.index();
   18411                         input.rewind();
   18412                         s = -1;
   18413                         if ( (synpred117_Java()) ) {s = 19;}
   18414 
   18415                         else if ( (synpred118_Java()) ) {s = 20;}
   18416 
   18417                         else if ( (synpred119_Java()) ) {s = 15;}
   18418 
   18419                         else if ( (synpred120_Java()) ) {s = 16;}
   18420 
   18421                         else if ( (synpred121_Java()) ) {s = 17;}
   18422 
   18423                         else if ( (synpred122_Java()) ) {s = 21;}
   18424 
   18425 
   18426                         input.seek(index87_5);
   18427                         if ( s>=0 ) return s;
   18428                         break;
   18429                     case 5 :
   18430                         int LA87_6 = input.LA(1);
   18431 
   18432 
   18433                         int index87_6 = input.index();
   18434                         input.rewind();
   18435                         s = -1;
   18436                         if ( (synpred117_Java()) ) {s = 19;}
   18437 
   18438                         else if ( (synpred118_Java()) ) {s = 20;}
   18439 
   18440                         else if ( (synpred119_Java()) ) {s = 15;}
   18441 
   18442                         else if ( (synpred120_Java()) ) {s = 16;}
   18443 
   18444                         else if ( (synpred121_Java()) ) {s = 17;}
   18445 
   18446                         else if ( (synpred122_Java()) ) {s = 21;}
   18447 
   18448 
   18449                         input.seek(index87_6);
   18450                         if ( s>=0 ) return s;
   18451                         break;
   18452                     case 6 :
   18453                         int LA87_7 = input.LA(1);
   18454 
   18455 
   18456                         int index87_7 = input.index();
   18457                         input.rewind();
   18458                         s = -1;
   18459                         if ( (synpred117_Java()) ) {s = 19;}
   18460 
   18461                         else if ( (synpred118_Java()) ) {s = 20;}
   18462 
   18463                         else if ( (synpred119_Java()) ) {s = 15;}
   18464 
   18465                         else if ( (synpred120_Java()) ) {s = 16;}
   18466 
   18467                         else if ( (synpred121_Java()) ) {s = 17;}
   18468 
   18469                         else if ( (synpred122_Java()) ) {s = 21;}
   18470 
   18471 
   18472                         input.seek(index87_7);
   18473                         if ( s>=0 ) return s;
   18474                         break;
   18475                     case 7 :
   18476                         int LA87_8 = input.LA(1);
   18477 
   18478 
   18479                         int index87_8 = input.index();
   18480                         input.rewind();
   18481                         s = -1;
   18482                         if ( (synpred117_Java()) ) {s = 19;}
   18483 
   18484                         else if ( (synpred118_Java()) ) {s = 20;}
   18485 
   18486                         else if ( (synpred119_Java()) ) {s = 15;}
   18487 
   18488                         else if ( (synpred120_Java()) ) {s = 16;}
   18489 
   18490                         else if ( (synpred121_Java()) ) {s = 17;}
   18491 
   18492                         else if ( (synpred122_Java()) ) {s = 21;}
   18493 
   18494 
   18495                         input.seek(index87_8);
   18496                         if ( s>=0 ) return s;
   18497                         break;
   18498                     case 8 :
   18499                         int LA87_9 = input.LA(1);
   18500 
   18501 
   18502                         int index87_9 = input.index();
   18503                         input.rewind();
   18504                         s = -1;
   18505                         if ( (synpred117_Java()) ) {s = 19;}
   18506 
   18507                         else if ( (synpred118_Java()) ) {s = 20;}
   18508 
   18509                         else if ( (synpred119_Java()) ) {s = 15;}
   18510 
   18511                         else if ( (synpred120_Java()) ) {s = 16;}
   18512 
   18513                         else if ( (synpred121_Java()) ) {s = 17;}
   18514 
   18515                         else if ( (synpred122_Java()) ) {s = 21;}
   18516 
   18517 
   18518                         input.seek(index87_9);
   18519                         if ( s>=0 ) return s;
   18520                         break;
   18521                     case 9 :
   18522                         int LA87_10 = input.LA(1);
   18523 
   18524 
   18525                         int index87_10 = input.index();
   18526                         input.rewind();
   18527                         s = -1;
   18528                         if ( (synpred117_Java()) ) {s = 19;}
   18529 
   18530                         else if ( (synpred118_Java()) ) {s = 20;}
   18531 
   18532                         else if ( (synpred119_Java()) ) {s = 15;}
   18533 
   18534                         else if ( (synpred120_Java()) ) {s = 16;}
   18535 
   18536                         else if ( (synpred121_Java()) ) {s = 17;}
   18537 
   18538                         else if ( (synpred122_Java()) ) {s = 21;}
   18539 
   18540 
   18541                         input.seek(index87_10);
   18542                         if ( s>=0 ) return s;
   18543                         break;
   18544                     case 10 :
   18545                         int LA87_11 = input.LA(1);
   18546 
   18547 
   18548                         int index87_11 = input.index();
   18549                         input.rewind();
   18550                         s = -1;
   18551                         if ( (synpred117_Java()) ) {s = 19;}
   18552 
   18553                         else if ( (synpred118_Java()) ) {s = 20;}
   18554 
   18555                         else if ( (synpred119_Java()) ) {s = 15;}
   18556 
   18557                         else if ( (synpred120_Java()) ) {s = 16;}
   18558 
   18559                         else if ( (synpred121_Java()) ) {s = 17;}
   18560 
   18561                         else if ( (synpred122_Java()) ) {s = 21;}
   18562 
   18563 
   18564                         input.seek(index87_11);
   18565                         if ( s>=0 ) return s;
   18566                         break;
   18567                     case 11 :
   18568                         int LA87_12 = input.LA(1);
   18569 
   18570 
   18571                         int index87_12 = input.index();
   18572                         input.rewind();
   18573                         s = -1;
   18574                         if ( (synpred117_Java()) ) {s = 19;}
   18575 
   18576                         else if ( (synpred118_Java()) ) {s = 20;}
   18577 
   18578                         else if ( (synpred119_Java()) ) {s = 15;}
   18579 
   18580                         else if ( (synpred120_Java()) ) {s = 16;}
   18581 
   18582                         else if ( (synpred121_Java()) ) {s = 17;}
   18583 
   18584                         else if ( (synpred122_Java()) ) {s = 21;}
   18585 
   18586 
   18587                         input.seek(index87_12);
   18588                         if ( s>=0 ) return s;
   18589                         break;
   18590                     case 12 :
   18591                         int LA87_13 = input.LA(1);
   18592 
   18593 
   18594                         int index87_13 = input.index();
   18595                         input.rewind();
   18596                         s = -1;
   18597                         if ( (synpred117_Java()) ) {s = 19;}
   18598 
   18599                         else if ( (synpred118_Java()) ) {s = 20;}
   18600 
   18601 
   18602                         input.seek(index87_13);
   18603                         if ( s>=0 ) return s;
   18604                         break;
   18605                     case 13 :
   18606                         int LA87_14 = input.LA(1);
   18607 
   18608 
   18609                         int index87_14 = input.index();
   18610                         input.rewind();
   18611                         s = -1;
   18612                         if ( (synpred117_Java()) ) {s = 19;}
   18613 
   18614                         else if ( (synpred118_Java()) ) {s = 20;}
   18615 
   18616 
   18617                         input.seek(index87_14);
   18618                         if ( s>=0 ) return s;
   18619                         break;
   18620             }
   18621             if (state.backtracking>0) {state.failed=true; return -1;}
   18622             NoViableAltException nvae =
   18623                 new NoViableAltException(getDescription(), 87, _s, input);
   18624             error(nvae);
   18625             throw nvae;
   18626         }
   18627     }
   18628     static final String DFA90_eotS =
   18629         "\54\uffff";
   18630     static final String DFA90_eofS =
   18631         "\54\uffff";
   18632     static final String DFA90_minS =
   18633         "\1\4\4\0\6\uffff\1\0\40\uffff";
   18634     static final String DFA90_maxS =
   18635         "\1\162\4\0\6\uffff\1\0\40\uffff";
   18636     static final String DFA90_acceptS =
   18637         "\5\uffff\1\2\14\uffff\1\3\30\uffff\1\1";
   18638     static final String DFA90_specialS =
   18639         "\1\uffff\1\0\1\1\1\2\1\3\6\uffff\1\4\40\uffff}>";
   18640     static final String[] DFA90_transitionS = {
   18641             "\1\3\11\22\16\uffff\1\5\1\22\1\4\1\22\1\4\2\uffff\1\4\1\5\1"+
   18642             "\uffff\1\22\1\uffff\1\22\1\4\1\uffff\1\5\1\uffff\1\1\1\uffff"+
   18643             "\1\4\1\22\1\uffff\1\22\3\uffff\1\4\1\5\1\4\1\5\1\22\1\uffff"+
   18644             "\3\5\1\22\1\4\2\5\2\22\1\13\2\22\1\uffff\1\5\2\22\1\5\2\22\1"+
   18645             "\uffff\1\22\3\uffff\1\22\4\uffff\2\22\5\uffff\4\22\16\uffff"+
   18646             "\1\2",
   18647             "\1\uffff",
   18648             "\1\uffff",
   18649             "\1\uffff",
   18650             "\1\uffff",
   18651             "",
   18652             "",
   18653             "",
   18654             "",
   18655             "",
   18656             "",
   18657             "\1\uffff",
   18658             "",
   18659             "",
   18660             "",
   18661             "",
   18662             "",
   18663             "",
   18664             "",
   18665             "",
   18666             "",
   18667             "",
   18668             "",
   18669             "",
   18670             "",
   18671             "",
   18672             "",
   18673             "",
   18674             "",
   18675             "",
   18676             "",
   18677             "",
   18678             "",
   18679             "",
   18680             "",
   18681             "",
   18682             "",
   18683             "",
   18684             "",
   18685             "",
   18686             "",
   18687             "",
   18688             "",
   18689             ""
   18690     };
   18691 
   18692     static final short[] DFA90_eot = DFA.unpackEncodedString(DFA90_eotS);
   18693     static final short[] DFA90_eof = DFA.unpackEncodedString(DFA90_eofS);
   18694     static final char[] DFA90_min = DFA.unpackEncodedStringToUnsignedChars(DFA90_minS);
   18695     static final char[] DFA90_max = DFA.unpackEncodedStringToUnsignedChars(DFA90_maxS);
   18696     static final short[] DFA90_accept = DFA.unpackEncodedString(DFA90_acceptS);
   18697     static final short[] DFA90_special = DFA.unpackEncodedString(DFA90_specialS);
   18698     static final short[][] DFA90_transition;
   18699 
   18700     static {
   18701         int numStates = DFA90_transitionS.length;
   18702         DFA90_transition = new short[numStates][];
   18703         for (int i=0; i<numStates; i++) {
   18704             DFA90_transition[i] = DFA.unpackEncodedString(DFA90_transitionS[i]);
   18705         }
   18706     }
   18707 
   18708     class DFA90 extends DFA {
   18709 
   18710         public DFA90(BaseRecognizer recognizer) {
   18711             this.recognizer = recognizer;
   18712             this.decisionNumber = 90;
   18713             this.eot = DFA90_eot;
   18714             this.eof = DFA90_eof;
   18715             this.min = DFA90_min;
   18716             this.max = DFA90_max;
   18717             this.accept = DFA90_accept;
   18718             this.special = DFA90_special;
   18719             this.transition = DFA90_transition;
   18720         }
   18721         public String getDescription() {
   18722             return "823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );";
   18723         }
   18724         public void error(NoViableAltException nvae) {
   18725             dbg.recognitionException(nvae);
   18726         }
   18727         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   18728             TokenStream input = (TokenStream)_input;
   18729 		int _s = s;
   18730             switch ( s ) {
   18731                     case 0 :
   18732                         int LA90_1 = input.LA(1);
   18733 
   18734 
   18735                         int index90_1 = input.index();
   18736                         input.rewind();
   18737                         s = -1;
   18738                         if ( (synpred125_Java()) ) {s = 43;}
   18739 
   18740                         else if ( (synpred126_Java()) ) {s = 5;}
   18741 
   18742 
   18743                         input.seek(index90_1);
   18744                         if ( s>=0 ) return s;
   18745                         break;
   18746                     case 1 :
   18747                         int LA90_2 = input.LA(1);
   18748 
   18749 
   18750                         int index90_2 = input.index();
   18751                         input.rewind();
   18752                         s = -1;
   18753                         if ( (synpred125_Java()) ) {s = 43;}
   18754 
   18755                         else if ( (synpred126_Java()) ) {s = 5;}
   18756 
   18757 
   18758                         input.seek(index90_2);
   18759                         if ( s>=0 ) return s;
   18760                         break;
   18761                     case 2 :
   18762                         int LA90_3 = input.LA(1);
   18763 
   18764 
   18765                         int index90_3 = input.index();
   18766                         input.rewind();
   18767                         s = -1;
   18768                         if ( (synpred125_Java()) ) {s = 43;}
   18769 
   18770                         else if ( (true) ) {s = 18;}
   18771 
   18772 
   18773                         input.seek(index90_3);
   18774                         if ( s>=0 ) return s;
   18775                         break;
   18776                     case 3 :
   18777                         int LA90_4 = input.LA(1);
   18778 
   18779 
   18780                         int index90_4 = input.index();
   18781                         input.rewind();
   18782                         s = -1;
   18783                         if ( (synpred125_Java()) ) {s = 43;}
   18784 
   18785                         else if ( (true) ) {s = 18;}
   18786 
   18787 
   18788                         input.seek(index90_4);
   18789                         if ( s>=0 ) return s;
   18790                         break;
   18791                     case 4 :
   18792                         int LA90_11 = input.LA(1);
   18793 
   18794 
   18795                         int index90_11 = input.index();
   18796                         input.rewind();
   18797                         s = -1;
   18798                         if ( (synpred126_Java()) ) {s = 5;}
   18799 
   18800                         else if ( (true) ) {s = 18;}
   18801 
   18802 
   18803                         input.seek(index90_11);
   18804                         if ( s>=0 ) return s;
   18805                         break;
   18806             }
   18807             if (state.backtracking>0) {state.failed=true; return -1;}
   18808             NoViableAltException nvae =
   18809                 new NoViableAltException(getDescription(), 90, _s, input);
   18810             error(nvae);
   18811             throw nvae;
   18812         }
   18813     }
   18814     static final String DFA98_eotS =
   18815         "\40\uffff";
   18816     static final String DFA98_eofS =
   18817         "\40\uffff";
   18818     static final String DFA98_minS =
   18819         "\1\4\1\uffff\1\0\23\uffff\1\0\11\uffff";
   18820     static final String DFA98_maxS =
   18821         "\1\143\1\uffff\1\0\23\uffff\1\0\11\uffff";
   18822     static final String DFA98_acceptS =
   18823         "\1\uffff\1\1\1\uffff\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"+
   18824         "\15\1\16\1\17\15\uffff\1\21\1\2\1\3\1\20";
   18825     static final String DFA98_specialS =
   18826         "\2\uffff\1\0\23\uffff\1\1\11\uffff}>";
   18827     static final String[] DFA98_transitionS = {
   18828             "\1\26\11\16\17\uffff\1\2\1\16\1\14\1\16\2\uffff\1\16\2\uffff"+
   18829             "\1\15\1\uffff\1\6\1\16\5\uffff\1\16\1\4\1\uffff\1\3\3\uffff"+
   18830             "\1\16\1\uffff\1\16\1\uffff\1\16\4\uffff\1\12\1\16\2\uffff\1"+
   18831             "\16\1\10\1\11\1\16\1\13\2\uffff\1\7\1\16\1\uffff\1\5\1\16\1"+
   18832             "\uffff\1\1\3\uffff\1\34\4\uffff\2\16\5\uffff\4\16",
   18833             "",
   18834             "\1\uffff",
   18835             "",
   18836             "",
   18837             "",
   18838             "",
   18839             "",
   18840             "",
   18841             "",
   18842             "",
   18843             "",
   18844             "",
   18845             "",
   18846             "",
   18847             "",
   18848             "",
   18849             "",
   18850             "",
   18851             "",
   18852             "",
   18853             "",
   18854             "\1\uffff",
   18855             "",
   18856             "",
   18857             "",
   18858             "",
   18859             "",
   18860             "",
   18861             "",
   18862             "",
   18863             ""
   18864     };
   18865 
   18866     static final short[] DFA98_eot = DFA.unpackEncodedString(DFA98_eotS);
   18867     static final short[] DFA98_eof = DFA.unpackEncodedString(DFA98_eofS);
   18868     static final char[] DFA98_min = DFA.unpackEncodedStringToUnsignedChars(DFA98_minS);
   18869     static final char[] DFA98_max = DFA.unpackEncodedStringToUnsignedChars(DFA98_maxS);
   18870     static final short[] DFA98_accept = DFA.unpackEncodedString(DFA98_acceptS);
   18871     static final short[] DFA98_special = DFA.unpackEncodedString(DFA98_specialS);
   18872     static final short[][] DFA98_transition;
   18873 
   18874     static {
   18875         int numStates = DFA98_transitionS.length;
   18876         DFA98_transition = new short[numStates][];
   18877         for (int i=0; i<numStates; i++) {
   18878             DFA98_transition[i] = DFA.unpackEncodedString(DFA98_transitionS[i]);
   18879         }
   18880     }
   18881 
   18882     class DFA98 extends DFA {
   18883 
   18884         public DFA98(BaseRecognizer recognizer) {
   18885             this.recognizer = recognizer;
   18886             this.decisionNumber = 98;
   18887             this.eot = DFA98_eot;
   18888             this.eof = DFA98_eof;
   18889             this.min = DFA98_min;
   18890             this.max = DFA98_max;
   18891             this.accept = DFA98_accept;
   18892             this.special = DFA98_special;
   18893             this.transition = DFA98_transition;
   18894         }
   18895         public String getDescription() {
   18896             return "842:1: statement : ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' );";
   18897         }
   18898         public void error(NoViableAltException nvae) {
   18899             dbg.recognitionException(nvae);
   18900         }
   18901         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   18902             TokenStream input = (TokenStream)_input;
   18903 		int _s = s;
   18904             switch ( s ) {
   18905                     case 0 :
   18906                         int LA98_2 = input.LA(1);
   18907 
   18908 
   18909                         int index98_2 = input.index();
   18910                         input.rewind();
   18911                         s = -1;
   18912                         if ( (synpred130_Java()) ) {s = 29;}
   18913 
   18914                         else if ( (synpred132_Java()) ) {s = 30;}
   18915 
   18916 
   18917                         input.seek(index98_2);
   18918                         if ( s>=0 ) return s;
   18919                         break;
   18920                     case 1 :
   18921                         int LA98_22 = input.LA(1);
   18922 
   18923 
   18924                         int index98_22 = input.index();
   18925                         input.rewind();
   18926                         s = -1;
   18927                         if ( (synpred148_Java()) ) {s = 14;}
   18928 
   18929                         else if ( (synpred149_Java()) ) {s = 31;}
   18930 
   18931 
   18932                         input.seek(index98_22);
   18933                         if ( s>=0 ) return s;
   18934                         break;
   18935             }
   18936             if (state.backtracking>0) {state.failed=true; return -1;}
   18937             NoViableAltException nvae =
   18938                 new NoViableAltException(getDescription(), 98, _s, input);
   18939             error(nvae);
   18940             throw nvae;
   18941         }
   18942     }
   18943     static final String DFA109_eotS =
   18944         "\21\uffff";
   18945     static final String DFA109_eofS =
   18946         "\21\uffff";
   18947     static final String DFA109_minS =
   18948         "\1\4\2\uffff\2\0\14\uffff";
   18949     static final String DFA109_maxS =
   18950         "\1\162\2\uffff\2\0\14\uffff";
   18951     static final String DFA109_acceptS =
   18952         "\1\uffff\1\1\3\uffff\1\2\13\uffff";
   18953     static final String DFA109_specialS =
   18954         "\3\uffff\1\0\1\1\14\uffff}>";
   18955     static final String[] DFA109_transitionS = {
   18956             "\1\3\11\5\20\uffff\1\4\1\uffff\1\4\2\uffff\1\4\5\uffff\1\4\3"+
   18957             "\uffff\1\1\1\uffff\1\4\6\uffff\1\4\1\uffff\1\4\1\uffff\1\5\5"+
   18958             "\uffff\1\4\2\uffff\1\5\2\uffff\1\5\4\uffff\1\5\2\uffff\1\5\12"+
   18959             "\uffff\2\5\5\uffff\4\5\16\uffff\1\1",
   18960             "",
   18961             "",
   18962             "\1\uffff",
   18963             "\1\uffff",
   18964             "",
   18965             "",
   18966             "",
   18967             "",
   18968             "",
   18969             "",
   18970             "",
   18971             "",
   18972             "",
   18973             "",
   18974             "",
   18975             ""
   18976     };
   18977 
   18978     static final short[] DFA109_eot = DFA.unpackEncodedString(DFA109_eotS);
   18979     static final short[] DFA109_eof = DFA.unpackEncodedString(DFA109_eofS);
   18980     static final char[] DFA109_min = DFA.unpackEncodedStringToUnsignedChars(DFA109_minS);
   18981     static final char[] DFA109_max = DFA.unpackEncodedStringToUnsignedChars(DFA109_maxS);
   18982     static final short[] DFA109_accept = DFA.unpackEncodedString(DFA109_acceptS);
   18983     static final short[] DFA109_special = DFA.unpackEncodedString(DFA109_specialS);
   18984     static final short[][] DFA109_transition;
   18985 
   18986     static {
   18987         int numStates = DFA109_transitionS.length;
   18988         DFA109_transition = new short[numStates][];
   18989         for (int i=0; i<numStates; i++) {
   18990             DFA109_transition[i] = DFA.unpackEncodedString(DFA109_transitionS[i]);
   18991         }
   18992     }
   18993 
   18994     class DFA109 extends DFA {
   18995 
   18996         public DFA109(BaseRecognizer recognizer) {
   18997             this.recognizer = recognizer;
   18998             this.decisionNumber = 109;
   18999             this.eot = DFA109_eot;
   19000             this.eof = DFA109_eof;
   19001             this.min = DFA109_min;
   19002             this.max = DFA109_max;
   19003             this.accept = DFA109_accept;
   19004             this.special = DFA109_special;
   19005             this.transition = DFA109_transition;
   19006         }
   19007         public String getDescription() {
   19008             return "928:1: forInit : ( localVariableDeclaration | expressionList );";
   19009         }
   19010         public void error(NoViableAltException nvae) {
   19011             dbg.recognitionException(nvae);
   19012         }
   19013         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
   19014             TokenStream input = (TokenStream)_input;
   19015 		int _s = s;
   19016             switch ( s ) {
   19017                     case 0 :
   19018                         int LA109_3 = input.LA(1);
   19019 
   19020 
   19021                         int index109_3 = input.index();
   19022                         input.rewind();
   19023                         s = -1;
   19024                         if ( (synpred161_Java()) ) {s = 1;}
   19025 
   19026                         else if ( (true) ) {s = 5;}
   19027 
   19028 
   19029                         input.seek(index109_3);
   19030                         if ( s>=0 ) return s;
   19031                         break;
   19032                     case 1 :
   19033                         int LA109_4 = input.LA(1);
   19034 
   19035 
   19036                         int index109_4 = input.index();
   19037                         input.rewind();
   19038                         s = -1;
   19039                         if ( (synpred161_Java()) ) {s = 1;}
   19040 
   19041                         else if ( (true) ) {s = 5;}
   19042 
   19043 
   19044                         input.seek(index109_4);
   19045                         if ( s>=0 ) return s;
   19046                         break;
   19047             }
   19048             if (state.backtracking>0) {state.failed=true; return -1;}
   19049             NoViableAltException nvae =
   19050                 new NoViableAltException(getDescription(), 109, _s, input);
   19051             error(nvae);
   19052             throw nvae;
   19053         }
   19054     }
   19055     static final String DFA112_eotS =
   19056         "\17\uffff";
   19057     static final String DFA112_eofS =
   19058         "\17\uffff";
   19059     static final String DFA112_minS =
   19060         "\1\130\12\uffff\1\164\1\130\2\uffff";
   19061     static final String DFA112_maxS =
   19062         "\1\165\12\uffff\2\164\2\uffff";
   19063     static final String DFA112_acceptS =
   19064         "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\2\uffff\1\13"+
   19065         "\1\14";
   19066     static final String DFA112_specialS =
   19067         "\17\uffff}>";
   19068     static final String[] DFA112_transitionS = {
   19069             "\1\1\21\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\2\uffff\1\13"+
   19070             "\1\12",
   19071             "",
   19072             "",
   19073             "",
   19074             "",
   19075             "",
   19076             "",
   19077             "",
   19078             "",
   19079             "",
   19080             "",
   19081             "\1\14",
   19082             "\1\16\33\uffff\1\15",
   19083             "",
   19084             ""
   19085     };
   19086 
   19087     static final short[] DFA112_eot = DFA.unpackEncodedString(DFA112_eotS);
   19088     static final short[] DFA112_eof = DFA.unpackEncodedString(DFA112_eofS);
   19089     static final char[] DFA112_min = DFA.unpackEncodedStringToUnsignedChars(DFA112_minS);
   19090     static final char[] DFA112_max = DFA.unpackEncodedStringToUnsignedChars(DFA112_maxS);
   19091     static final short[] DFA112_accept = DFA.unpackEncodedString(