• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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;
getRuleLevel()428         public int getRuleLevel() { return ruleLevel; }
incRuleLevel()429         public void incRuleLevel() { ruleLevel++; }
decRuleLevel()430         public void decRuleLevel() { ruleLevel--; }
JavaParser(TokenStream input)431         public JavaParser(TokenStream input) {
432             this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
433         }
JavaParser(TokenStream input, int port, RecognizerSharedState state)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         }
JavaParser(TokenStream input, DebugEventListener dbg)448     public JavaParser(TokenStream input, DebugEventListener dbg) {
449         super(input, dbg, new RecognizerSharedState());
450         this.state.ruleMemo = new HashMap[381+1];
451 
452     }
evalPredicate(boolean result, String predicate)453     protected boolean evalPredicate(boolean result, String predicate) {
454         dbg.semanticPredicate(result, predicate);
455         return result;
456     }
457 
458 
getTokenNames()459     public String[] getTokenNames() { return JavaParser.tokenNames; }
getGrammarFileName()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 )* ;
compilationUnit()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 ';' ;
packageDeclaration()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 )+ ( '.' '*' )? ';' );
importDeclaration()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 )* ;
qualifiedImportName()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 | ';' );
typeDeclaration()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 );
classOrInterfaceDeclaration()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' )* ;
modifiers()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 )* ;
variableModifiers()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 );
classDeclaration()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 ;
normalClassDeclaration()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 )* '>' ;
typeParameters()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 )? ;
typeParameter()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 )* ;
typeBound()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 ;
enumDeclaration()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 )? '}' ;
enumBody()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 )* ;
enumConstants()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 )? ;
enumConstant()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 )* ;
enumBodyDeclarations()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 );
interfaceDeclaration()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 ;
normalInterfaceDeclaration()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 )* ;
typeList()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 )* '}' ;
classBody()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 )* '}' ;
interfaceBody()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 );
classBodyDeclaration()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 );
memberDecl()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 | ';' ) );
methodDeclaration()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 )* ';' ;
fieldDeclaration()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 )? ;
variableDeclarator()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 | ';' );
interfaceBodyDeclaration()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 )? ';' ;
interfaceMethodDeclaration()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 )* ';' ;
interfaceFieldDeclaration()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 ( '[' ']' )* );
type()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 )? )* ;
classOrInterfaceType()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' );
primitiveType()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 )* '>' ;
typeArguments()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 )? );
typeArgument()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 )* ;
qualifiedNameList()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 )? ')' ;
formalParameters()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 );
formalParameterDecls()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 ( '[' ']' )* ;
normalParameterDecl()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 ;
ellipsisParameterDecl()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 ';' );
explicitConstructorInvocation()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 )* ;
qualifiedName()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 )+ ;
annotations()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 )? ')' )? ;
annotation()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 )* ;
elementValuePairs()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 ;
elementValuePair()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 );
elementValue()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 )* )? ( ',' )? '}' ;
elementValueArrayInitializer()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 ;
annotationTypeDeclaration()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 )* '}' ;
annotationTypeBody()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 | ';' );
annotationTypeElementDeclaration()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 )? ';' ;
annotationMethodDeclaration()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 )* '}' ;
block()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 );
blockStatement()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 ';' ;
localVariableDeclarationStatement()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 )* ;
localVariableDeclaration()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 | ';' );
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 )* ;
switchBlockStatementGroups()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 )* ;
switchBlockStatementGroup()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' ':' );
switchLabel()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 ) ;
trystatement()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 )* ;
catches()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 ;
catchClause()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 ( '[' ']' )* ;
formalParameter()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 );
forstatement()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 );
forInit()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 ')' ;
parExpression()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 )* ;
expressionList()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 )? ;
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 : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' );
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 )? ;
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 )* ;
conditionalOrExpression()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 )* ;
conditionalAndExpression()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 )* ;
inclusiveOrExpression()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 )* ;
exclusiveOrExpression()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 )* ;
andExpression()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 )* ;
equalityExpression()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 )? ;
instanceOfExpression()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 )* ;
relationalExpression()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 : ( '<' '=' | '>' '=' | '<' | '>' );
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 )* ;
shiftExpression()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 : ( '<' '<' | '>' '>' '>' | '>' '>' );
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 )* ;
additiveExpression()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 )* ;
multiplicativeExpression()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 );
unaryExpression()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 )* ( '++' | '--' )? );
unaryExpressionNotPlusMinus()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 );
castExpression()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' );
primary()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 )? );
superSuffix()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 );
identifierSuffix()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 ']' );
selector()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 );
creator()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 ']' )* ( '[' ']' )* );
arrayCreator()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 );
variableInitializer()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 )* )? ( ',' )? '}' ;
arrayInitializer()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 );
createdName()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 ;
innerCreator()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 )? ;
classCreatorRest()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 '>' ;
nonWildcardTypeArguments()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 )? ')' ;
arguments()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 );
literal()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 ;
classHeader()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 ;
enumHeader()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 ;
interfaceHeader()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 ;
annotationHeader()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 ;
typeHeader()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 '(' ;
methodHeader()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 ( '[' ']' )* ( '=' | ',' | ';' ) ;
fieldHeader()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 ( '[' ']' )* ( '=' | ',' | ';' ) ;
localVariableHeader()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
synpred2_Java_fragment()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
synpred12_Java_fragment()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
synpred27_Java_fragment()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
synpred43_Java_fragment()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
synpred52_Java_fragment()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
synpred53_Java_fragment()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
synpred54_Java_fragment()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
synpred57_Java_fragment()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
synpred59_Java_fragment()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
synpred68_Java_fragment()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
synpred69_Java_fragment()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
synpred70_Java_fragment()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
synpred71_Java_fragment()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
synpred96_Java_fragment()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
synpred98_Java_fragment()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
synpred99_Java_fragment()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
synpred103_Java_fragment()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
synpred117_Java_fragment()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
synpred118_Java_fragment()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
synpred119_Java_fragment()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
synpred120_Java_fragment()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
synpred121_Java_fragment()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
synpred122_Java_fragment()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
synpred125_Java_fragment()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
synpred126_Java_fragment()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
synpred130_Java_fragment()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
synpred132_Java_fragment()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
synpred133_Java_fragment()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
synpred148_Java_fragment()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
synpred149_Java_fragment()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
synpred153_Java_fragment()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
synpred154_Java_fragment()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
synpred157_Java_fragment()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
synpred161_Java_fragment()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
synpred202_Java_fragment()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
synpred206_Java_fragment()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
synpred208_Java_fragment()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
synpred209_Java_fragment()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
synpred211_Java_fragment()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
synpred212_Java_fragment()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
synpred224_Java_fragment()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
synpred236_Java_fragment()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
synpred237_Java_fragment()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
synpred239_Java_fragment()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
synpred240_Java_fragment()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 
synpred43_Java()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     }
synpred98_Java()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     }
synpred157_Java()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     }
synpred224_Java()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     }
synpred211_Java()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     }
synpred121_Java()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     }
synpred239_Java()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     }
synpred69_Java()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     }
synpred202_Java()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     }
synpred154_Java()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     }
synpred71_Java()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     }
synpred133_Java()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     }
synpred125_Java()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     }
synpred132_Java()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     }
synpred119_Java()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     }
synpred54_Java()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     }
synpred148_Java()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     }
synpred117_Java()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     }
synpred2_Java()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     }
synpred130_Java()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     }
synpred126_Java()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     }
synpred59_Java()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     }
synpred212_Java()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     }
synpred161_Java()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     }
synpred57_Java()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     }
synpred209_Java()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     }
synpred68_Java()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     }
synpred53_Java()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     }
synpred52_Java()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     }
synpred236_Java()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     }
synpred12_Java()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     }
synpred149_Java()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     }
synpred120_Java()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     }
synpred122_Java()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     }
synpred240_Java()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     }
synpred206_Java()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     }
synpred70_Java()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     }
synpred27_Java()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     }
synpred96_Java()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     }
synpred153_Java()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     }
synpred99_Java()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     }
synpred103_Java()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     }
synpred237_Java()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     }
synpred118_Java()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     }
synpred208_Java()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 
DFA2(BaseRecognizer recognizer)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         }
getDescription()16029         public String getDescription() {
16030             return "298:9: ( ( annotations )? packageDeclaration )?";
16031         }
error(NoViableAltException nvae)16032         public void error(NoViableAltException nvae) {
16033             dbg.recognitionException(nvae);
16034         }
specialStateTransition(int s, IntStream _input)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 
DFA12(BaseRecognizer recognizer)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         }
getDescription()16124         public String getDescription() {
16125             return "341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );";
16126         }
error(NoViableAltException nvae)16127         public void error(NoViableAltException nvae) {
16128             dbg.recognitionException(nvae);
16129         }
specialStateTransition(int s, IntStream _input)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 
DFA13(BaseRecognizer recognizer)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         }
getDescription()16385         public String getDescription() {
16386             return "()* loopback of 349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*";
16387         }
error(NoViableAltException nvae)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 
DFA15(BaseRecognizer recognizer)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         }
getDescription()16453         public String getDescription() {
16454             return "372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );";
16455         }
error(NoViableAltException nvae)16456         public void error(NoViableAltException nvae) {
16457             dbg.recognitionException(nvae);
16458         }
specialStateTransition(int s, IntStream _input)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 
DFA31(BaseRecognizer recognizer)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         }
getDescription()16712         public String getDescription() {
16713             return "460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );";
16714         }
error(NoViableAltException nvae)16715         public void error(NoViableAltException nvae) {
16716             dbg.recognitionException(nvae);
16717         }
specialStateTransition(int s, IntStream _input)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 
DFA39(BaseRecognizer recognizer)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         }
getDescription()16980         public String getDescription() {
16981             return "502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );";
16982         }
error(NoViableAltException nvae)16983         public void error(NoViableAltException nvae) {
16984             dbg.recognitionException(nvae);
16985         }
specialStateTransition(int s, IntStream _input)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 
DFA49(BaseRecognizer recognizer)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         }
getDescription()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         }
error(NoViableAltException nvae)17325         public void error(NoViableAltException nvae) {
17326             dbg.recognitionException(nvae);
17327         }
specialStateTransition(int s, IntStream _input)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 
DFA42(BaseRecognizer recognizer)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         }
getDescription()17644         public String getDescription() {
17645             return "521:9: ( explicitConstructorInvocation )?";
17646         }
error(NoViableAltException nvae)17647         public void error(NoViableAltException nvae) {
17648             dbg.recognitionException(nvae);
17649         }
specialStateTransition(int s, IntStream _input)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 
DFA53(BaseRecognizer recognizer)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         }
getDescription()17853         public String getDescription() {
17854             return "562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' );";
17855         }
error(NoViableAltException nvae)17856         public void error(NoViableAltException nvae) {
17857             dbg.recognitionException(nvae);
17858         }
specialStateTransition(int s, IntStream _input)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 
DFA76(BaseRecognizer recognizer)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         }
getDescription()18185         public String getDescription() {
18186             return "688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' );";
18187         }
error(NoViableAltException nvae)18188         public void error(NoViableAltException nvae) {
18189             dbg.recognitionException(nvae);
18190         }
specialStateTransition(int s, IntStream _input)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 
DFA87(BaseRecognizer recognizer)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         }
getDescription()18304         public String getDescription() {
18305             return "772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' );";
18306         }
error(NoViableAltException nvae)18307         public void error(NoViableAltException nvae) {
18308             dbg.recognitionException(nvae);
18309         }
specialStateTransition(int s, IntStream _input)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 
DFA90(BaseRecognizer recognizer)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         }
getDescription()18721         public String getDescription() {
18722             return "823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );";
18723         }
error(NoViableAltException nvae)18724         public void error(NoViableAltException nvae) {
18725             dbg.recognitionException(nvae);
18726         }
specialStateTransition(int s, IntStream _input)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 
DFA98(BaseRecognizer recognizer)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         }
getDescription()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         }
error(NoViableAltException nvae)18898         public void error(NoViableAltException nvae) {
18899             dbg.recognitionException(nvae);
18900         }
specialStateTransition(int s, IntStream _input)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 
DFA109(BaseRecognizer recognizer)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         }
getDescription()19007         public String getDescription() {
19008             return "928:1: forInit : ( localVariableDeclaration | expressionList );";
19009         }
error(NoViableAltException nvae)19010         public void error(NoViableAltException nvae) {
19011             dbg.recognitionException(nvae);
19012         }
specialStateTransition(int s, IntStream _input)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(DFA112_acceptS);
19092     static final short[] DFA112_special = DFA.unpackEncodedString(DFA112_specialS);
19093     static final short[][] DFA112_transition;
19094 
19095     static {
19096         int numStates = DFA112_transitionS.length;
19097         DFA112_transition = new short[numStates][];
19098         for (int i=0; i<numStates; i++) {
19099             DFA112_transition[i] = DFA.unpackEncodedString(DFA112_transitionS[i]);
19100         }
19101     }
19102 
19103     class DFA112 extends DFA {
19104 
DFA112(BaseRecognizer recognizer)19105         public DFA112(BaseRecognizer recognizer) {
19106             this.recognizer = recognizer;
19107             this.decisionNumber = 112;
19108             this.eot = DFA112_eot;
19109             this.eof = DFA112_eof;
19110             this.min = DFA112_min;
19111             this.max = DFA112_max;
19112             this.accept = DFA112_accept;
19113             this.special = DFA112_special;
19114             this.transition = DFA112_transition;
19115         }
getDescription()19116         public String getDescription() {
19117             return "951:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' );";
19118         }
error(NoViableAltException nvae)19119         public void error(NoViableAltException nvae) {
19120             dbg.recognitionException(nvae);
19121         }
19122     }
19123     static final String DFA130_eotS =
19124         "\14\uffff";
19125     static final String DFA130_eofS =
19126         "\14\uffff";
19127     static final String DFA130_minS =
19128         "\1\4\2\uffff\1\0\10\uffff";
19129     static final String DFA130_maxS =
19130         "\1\132\2\uffff\1\0\10\uffff";
19131     static final String DFA130_acceptS =
19132         "\1\uffff\1\1\1\2\1\uffff\1\4\6\uffff\1\3";
19133     static final String DFA130_specialS =
19134         "\3\uffff\1\0\10\uffff}>";
19135     static final String[] DFA130_transitionS = {
19136             "\12\4\20\uffff\1\4\1\uffff\1\4\2\uffff\1\4\5\uffff\1\4\5\uffff"+
19137             "\1\4\6\uffff\1\4\1\uffff\1\4\1\uffff\1\4\5\uffff\1\4\2\uffff"+
19138             "\1\4\2\uffff\1\4\4\uffff\1\4\2\uffff\1\3\12\uffff\1\2\1\1",
19139             "",
19140             "",
19141             "\1\uffff",
19142             "",
19143             "",
19144             "",
19145             "",
19146             "",
19147             "",
19148             "",
19149             ""
19150     };
19151 
19152     static final short[] DFA130_eot = DFA.unpackEncodedString(DFA130_eotS);
19153     static final short[] DFA130_eof = DFA.unpackEncodedString(DFA130_eofS);
19154     static final char[] DFA130_min = DFA.unpackEncodedStringToUnsignedChars(DFA130_minS);
19155     static final char[] DFA130_max = DFA.unpackEncodedStringToUnsignedChars(DFA130_maxS);
19156     static final short[] DFA130_accept = DFA.unpackEncodedString(DFA130_acceptS);
19157     static final short[] DFA130_special = DFA.unpackEncodedString(DFA130_specialS);
19158     static final short[][] DFA130_transition;
19159 
19160     static {
19161         int numStates = DFA130_transitionS.length;
19162         DFA130_transition = new short[numStates][];
19163         for (int i=0; i<numStates; i++) {
19164             DFA130_transition[i] = DFA.unpackEncodedString(DFA130_transitionS[i]);
19165         }
19166     }
19167 
19168     class DFA130 extends DFA {
19169 
DFA130(BaseRecognizer recognizer)19170         public DFA130(BaseRecognizer recognizer) {
19171             this.recognizer = recognizer;
19172             this.decisionNumber = 130;
19173             this.eot = DFA130_eot;
19174             this.eof = DFA130_eof;
19175             this.min = DFA130_min;
19176             this.max = DFA130_max;
19177             this.accept = DFA130_accept;
19178             this.special = DFA130_special;
19179             this.transition = DFA130_transition;
19180         }
getDescription()19181         public String getDescription() {
19182             return "1080:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? );";
19183         }
error(NoViableAltException nvae)19184         public void error(NoViableAltException nvae) {
19185             dbg.recognitionException(nvae);
19186         }
specialStateTransition(int s, IntStream _input)19187         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
19188             TokenStream input = (TokenStream)_input;
19189 		int _s = s;
19190             switch ( s ) {
19191                     case 0 :
19192                         int LA130_3 = input.LA(1);
19193 
19194 
19195                         int index130_3 = input.index();
19196                         input.rewind();
19197                         s = -1;
19198                         if ( (synpred202_Java()) ) {s = 11;}
19199 
19200                         else if ( (true) ) {s = 4;}
19201 
19202 
19203                         input.seek(index130_3);
19204                         if ( s>=0 ) return s;
19205                         break;
19206             }
19207             if (state.backtracking>0) {state.failed=true; return -1;}
19208             NoViableAltException nvae =
19209                 new NoViableAltException(getDescription(), 130, _s, input);
19210             error(nvae);
19211             throw nvae;
19212         }
19213     }
19214     static final String DFA133_eotS =
19215         "\41\uffff";
19216     static final String DFA133_eofS =
19217         "\1\4\40\uffff";
19218     static final String DFA133_minS =
19219         "\1\65\1\0\1\uffff\1\0\35\uffff";
19220     static final String DFA133_maxS =
19221         "\1\165\1\0\1\uffff\1\0\35\uffff";
19222     static final String DFA133_acceptS =
19223         "\2\uffff\1\1\1\uffff\1\2\34\uffff";
19224     static final String DFA133_specialS =
19225         "\1\uffff\1\0\1\uffff\1\1\35\uffff}>";
19226     static final String[] DFA133_transitionS = {
19227             "\1\4\30\uffff\1\2\1\4\1\uffff\1\4\1\1\3\4\1\3\1\uffff\1\4\2"+
19228             "\uffff\27\4\1\uffff\3\4",
19229             "\1\uffff",
19230             "",
19231             "\1\uffff",
19232             "",
19233             "",
19234             "",
19235             "",
19236             "",
19237             "",
19238             "",
19239             "",
19240             "",
19241             "",
19242             "",
19243             "",
19244             "",
19245             "",
19246             "",
19247             "",
19248             "",
19249             "",
19250             "",
19251             "",
19252             "",
19253             "",
19254             "",
19255             "",
19256             "",
19257             "",
19258             "",
19259             "",
19260             ""
19261     };
19262 
19263     static final short[] DFA133_eot = DFA.unpackEncodedString(DFA133_eotS);
19264     static final short[] DFA133_eof = DFA.unpackEncodedString(DFA133_eofS);
19265     static final char[] DFA133_min = DFA.unpackEncodedStringToUnsignedChars(DFA133_minS);
19266     static final char[] DFA133_max = DFA.unpackEncodedStringToUnsignedChars(DFA133_maxS);
19267     static final short[] DFA133_accept = DFA.unpackEncodedString(DFA133_acceptS);
19268     static final short[] DFA133_special = DFA.unpackEncodedString(DFA133_specialS);
19269     static final short[][] DFA133_transition;
19270 
19271     static {
19272         int numStates = DFA133_transitionS.length;
19273         DFA133_transition = new short[numStates][];
19274         for (int i=0; i<numStates; i++) {
19275             DFA133_transition[i] = DFA.unpackEncodedString(DFA133_transitionS[i]);
19276         }
19277     }
19278 
19279     class DFA133 extends DFA {
19280 
DFA133(BaseRecognizer recognizer)19281         public DFA133(BaseRecognizer recognizer) {
19282             this.recognizer = recognizer;
19283             this.decisionNumber = 133;
19284             this.eot = DFA133_eot;
19285             this.eof = DFA133_eof;
19286             this.min = DFA133_min;
19287             this.max = DFA133_max;
19288             this.accept = DFA133_accept;
19289             this.special = DFA133_special;
19290             this.transition = DFA133_transition;
19291         }
getDescription()19292         public String getDescription() {
19293             return "1105:9: ( identifierSuffix )?";
19294         }
error(NoViableAltException nvae)19295         public void error(NoViableAltException nvae) {
19296             dbg.recognitionException(nvae);
19297         }
specialStateTransition(int s, IntStream _input)19298         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
19299             TokenStream input = (TokenStream)_input;
19300 		int _s = s;
19301             switch ( s ) {
19302                     case 0 :
19303                         int LA133_1 = input.LA(1);
19304 
19305 
19306                         int index133_1 = input.index();
19307                         input.rewind();
19308                         s = -1;
19309                         if ( (synpred209_Java()) ) {s = 2;}
19310 
19311                         else if ( (true) ) {s = 4;}
19312 
19313 
19314                         input.seek(index133_1);
19315                         if ( s>=0 ) return s;
19316                         break;
19317                     case 1 :
19318                         int LA133_3 = input.LA(1);
19319 
19320 
19321                         int index133_3 = input.index();
19322                         input.rewind();
19323                         s = -1;
19324                         if ( (synpred209_Java()) ) {s = 2;}
19325 
19326                         else if ( (true) ) {s = 4;}
19327 
19328 
19329                         input.seek(index133_3);
19330                         if ( s>=0 ) return s;
19331                         break;
19332             }
19333             if (state.backtracking>0) {state.failed=true; return -1;}
19334             NoViableAltException nvae =
19335                 new NoViableAltException(getDescription(), 133, _s, input);
19336             error(nvae);
19337             throw nvae;
19338         }
19339     }
19340     static final String DFA135_eotS =
19341         "\41\uffff";
19342     static final String DFA135_eofS =
19343         "\1\4\40\uffff";
19344     static final String DFA135_minS =
19345         "\1\65\1\0\1\uffff\1\0\35\uffff";
19346     static final String DFA135_maxS =
19347         "\1\165\1\0\1\uffff\1\0\35\uffff";
19348     static final String DFA135_acceptS =
19349         "\2\uffff\1\1\1\uffff\1\2\34\uffff";
19350     static final String DFA135_specialS =
19351         "\1\uffff\1\0\1\uffff\1\1\35\uffff}>";
19352     static final String[] DFA135_transitionS = {
19353             "\1\4\30\uffff\1\2\1\4\1\uffff\1\4\1\1\3\4\1\3\1\uffff\1\4\2"+
19354             "\uffff\27\4\1\uffff\3\4",
19355             "\1\uffff",
19356             "",
19357             "\1\uffff",
19358             "",
19359             "",
19360             "",
19361             "",
19362             "",
19363             "",
19364             "",
19365             "",
19366             "",
19367             "",
19368             "",
19369             "",
19370             "",
19371             "",
19372             "",
19373             "",
19374             "",
19375             "",
19376             "",
19377             "",
19378             "",
19379             "",
19380             "",
19381             "",
19382             "",
19383             "",
19384             "",
19385             "",
19386             ""
19387     };
19388 
19389     static final short[] DFA135_eot = DFA.unpackEncodedString(DFA135_eotS);
19390     static final short[] DFA135_eof = DFA.unpackEncodedString(DFA135_eofS);
19391     static final char[] DFA135_min = DFA.unpackEncodedStringToUnsignedChars(DFA135_minS);
19392     static final char[] DFA135_max = DFA.unpackEncodedStringToUnsignedChars(DFA135_maxS);
19393     static final short[] DFA135_accept = DFA.unpackEncodedString(DFA135_acceptS);
19394     static final short[] DFA135_special = DFA.unpackEncodedString(DFA135_specialS);
19395     static final short[][] DFA135_transition;
19396 
19397     static {
19398         int numStates = DFA135_transitionS.length;
19399         DFA135_transition = new short[numStates][];
19400         for (int i=0; i<numStates; i++) {
19401             DFA135_transition[i] = DFA.unpackEncodedString(DFA135_transitionS[i]);
19402         }
19403     }
19404 
19405     class DFA135 extends DFA {
19406 
DFA135(BaseRecognizer recognizer)19407         public DFA135(BaseRecognizer recognizer) {
19408             this.recognizer = recognizer;
19409             this.decisionNumber = 135;
19410             this.eot = DFA135_eot;
19411             this.eof = DFA135_eof;
19412             this.min = DFA135_min;
19413             this.max = DFA135_max;
19414             this.accept = DFA135_accept;
19415             this.special = DFA135_special;
19416             this.transition = DFA135_transition;
19417         }
getDescription()19418         public String getDescription() {
19419             return "1110:9: ( identifierSuffix )?";
19420         }
error(NoViableAltException nvae)19421         public void error(NoViableAltException nvae) {
19422             dbg.recognitionException(nvae);
19423         }
specialStateTransition(int s, IntStream _input)19424         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
19425             TokenStream input = (TokenStream)_input;
19426 		int _s = s;
19427             switch ( s ) {
19428                     case 0 :
19429                         int LA135_1 = input.LA(1);
19430 
19431 
19432                         int index135_1 = input.index();
19433                         input.rewind();
19434                         s = -1;
19435                         if ( (synpred212_Java()) ) {s = 2;}
19436 
19437                         else if ( (true) ) {s = 4;}
19438 
19439 
19440                         input.seek(index135_1);
19441                         if ( s>=0 ) return s;
19442                         break;
19443                     case 1 :
19444                         int LA135_3 = input.LA(1);
19445 
19446 
19447                         int index135_3 = input.index();
19448                         input.rewind();
19449                         s = -1;
19450                         if ( (synpred212_Java()) ) {s = 2;}
19451 
19452                         else if ( (true) ) {s = 4;}
19453 
19454 
19455                         input.seek(index135_3);
19456                         if ( s>=0 ) return s;
19457                         break;
19458             }
19459             if (state.backtracking>0) {state.failed=true; return -1;}
19460             NoViableAltException nvae =
19461                 new NoViableAltException(getDescription(), 135, _s, input);
19462             error(nvae);
19463             throw nvae;
19464         }
19465     }
19466     static final String DFA143_eotS =
19467         "\13\uffff";
19468     static final String DFA143_eofS =
19469         "\13\uffff";
19470     static final String DFA143_minS =
19471         "\1\116\1\4\1\uffff\1\44\7\uffff";
19472     static final String DFA143_maxS =
19473         "\1\126\1\143\1\uffff\1\165\7\uffff";
19474     static final String DFA143_acceptS =
19475         "\2\uffff\1\3\1\uffff\1\1\1\2\1\4\1\6\1\7\1\10\1\5";
19476     static final String DFA143_specialS =
19477         "\13\uffff}>";
19478     static final String[] DFA143_transitionS = {
19479             "\1\2\3\uffff\1\1\3\uffff\1\3",
19480             "\12\5\20\uffff\1\5\1\uffff\1\5\2\uffff\1\5\5\uffff\1\5\5\uffff"+
19481             "\1\5\6\uffff\1\5\1\uffff\1\5\1\uffff\1\5\5\uffff\1\5\2\uffff"+
19482             "\1\5\2\uffff\1\5\4\uffff\1\5\2\uffff\1\5\4\uffff\1\4\5\uffff"+
19483             "\2\5\5\uffff\4\5",
19484             "",
19485             "\1\6\25\uffff\1\11\10\uffff\1\10\2\uffff\1\7\56\uffff\1\12",
19486             "",
19487             "",
19488             "",
19489             "",
19490             "",
19491             "",
19492             ""
19493     };
19494 
19495     static final short[] DFA143_eot = DFA.unpackEncodedString(DFA143_eotS);
19496     static final short[] DFA143_eof = DFA.unpackEncodedString(DFA143_eofS);
19497     static final char[] DFA143_min = DFA.unpackEncodedStringToUnsignedChars(DFA143_minS);
19498     static final char[] DFA143_max = DFA.unpackEncodedStringToUnsignedChars(DFA143_maxS);
19499     static final short[] DFA143_accept = DFA.unpackEncodedString(DFA143_acceptS);
19500     static final short[] DFA143_special = DFA.unpackEncodedString(DFA143_specialS);
19501     static final short[][] DFA143_transition;
19502 
19503     static {
19504         int numStates = DFA143_transitionS.length;
19505         DFA143_transition = new short[numStates][];
19506         for (int i=0; i<numStates; i++) {
19507             DFA143_transition[i] = DFA.unpackEncodedString(DFA143_transitionS[i]);
19508         }
19509     }
19510 
19511     class DFA143 extends DFA {
19512 
DFA143(BaseRecognizer recognizer)19513         public DFA143(BaseRecognizer recognizer) {
19514             this.recognizer = recognizer;
19515             this.decisionNumber = 143;
19516             this.eot = DFA143_eot;
19517             this.eof = DFA143_eof;
19518             this.min = DFA143_min;
19519             this.max = DFA143_max;
19520             this.accept = DFA143_accept;
19521             this.special = DFA143_special;
19522             this.transition = DFA143_transition;
19523         }
getDescription()19524         public String getDescription() {
19525             return "1134:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator );";
19526         }
error(NoViableAltException nvae)19527         public void error(NoViableAltException nvae) {
19528             dbg.recognitionException(nvae);
19529         }
19530     }
19531     static final String DFA142_eotS =
19532         "\41\uffff";
19533     static final String DFA142_eofS =
19534         "\1\1\40\uffff";
19535     static final String DFA142_minS =
19536         "\1\65\1\uffff\1\0\36\uffff";
19537     static final String DFA142_maxS =
19538         "\1\165\1\uffff\1\0\36\uffff";
19539     static final String DFA142_acceptS =
19540         "\1\uffff\1\2\36\uffff\1\1";
19541     static final String DFA142_specialS =
19542         "\2\uffff\1\0\36\uffff}>";
19543     static final String[] DFA142_transitionS = {
19544             "\1\1\31\uffff\1\1\1\uffff\1\1\1\2\4\1\1\uffff\1\1\2\uffff\27"+
19545             "\1\1\uffff\3\1",
19546             "",
19547             "\1\uffff",
19548             "",
19549             "",
19550             "",
19551             "",
19552             "",
19553             "",
19554             "",
19555             "",
19556             "",
19557             "",
19558             "",
19559             "",
19560             "",
19561             "",
19562             "",
19563             "",
19564             "",
19565             "",
19566             "",
19567             "",
19568             "",
19569             "",
19570             "",
19571             "",
19572             "",
19573             "",
19574             "",
19575             "",
19576             "",
19577             ""
19578     };
19579 
19580     static final short[] DFA142_eot = DFA.unpackEncodedString(DFA142_eotS);
19581     static final short[] DFA142_eof = DFA.unpackEncodedString(DFA142_eofS);
19582     static final char[] DFA142_min = DFA.unpackEncodedStringToUnsignedChars(DFA142_minS);
19583     static final char[] DFA142_max = DFA.unpackEncodedStringToUnsignedChars(DFA142_maxS);
19584     static final short[] DFA142_accept = DFA.unpackEncodedString(DFA142_acceptS);
19585     static final short[] DFA142_special = DFA.unpackEncodedString(DFA142_specialS);
19586     static final short[][] DFA142_transition;
19587 
19588     static {
19589         int numStates = DFA142_transitionS.length;
19590         DFA142_transition = new short[numStates][];
19591         for (int i=0; i<numStates; i++) {
19592             DFA142_transition[i] = DFA.unpackEncodedString(DFA142_transitionS[i]);
19593         }
19594     }
19595 
19596     class DFA142 extends DFA {
19597 
DFA142(BaseRecognizer recognizer)19598         public DFA142(BaseRecognizer recognizer) {
19599             this.recognizer = recognizer;
19600             this.decisionNumber = 142;
19601             this.eot = DFA142_eot;
19602             this.eof = DFA142_eof;
19603             this.min = DFA142_min;
19604             this.max = DFA142_max;
19605             this.accept = DFA142_accept;
19606             this.special = DFA142_special;
19607             this.transition = DFA142_transition;
19608         }
getDescription()19609         public String getDescription() {
19610             return "()+ loopback of 1138:9: ( '[' expression ']' )+";
19611         }
error(NoViableAltException nvae)19612         public void error(NoViableAltException nvae) {
19613             dbg.recognitionException(nvae);
19614         }
specialStateTransition(int s, IntStream _input)19615         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
19616             TokenStream input = (TokenStream)_input;
19617 		int _s = s;
19618             switch ( s ) {
19619                     case 0 :
19620                         int LA142_2 = input.LA(1);
19621 
19622 
19623                         int index142_2 = input.index();
19624                         input.rewind();
19625                         s = -1;
19626                         if ( (synpred224_Java()) ) {s = 32;}
19627 
19628                         else if ( (true) ) {s = 1;}
19629 
19630 
19631                         input.seek(index142_2);
19632                         if ( s>=0 ) return s;
19633                         break;
19634             }
19635             if (state.backtracking>0) {state.failed=true; return -1;}
19636             NoViableAltException nvae =
19637                 new NoViableAltException(getDescription(), 142, _s, input);
19638             error(nvae);
19639             throw nvae;
19640         }
19641     }
19642     static final String DFA148_eotS =
19643         "\41\uffff";
19644     static final String DFA148_eofS =
19645         "\1\2\40\uffff";
19646     static final String DFA148_minS =
19647         "\1\65\1\0\37\uffff";
19648     static final String DFA148_maxS =
19649         "\1\165\1\0\37\uffff";
19650     static final String DFA148_acceptS =
19651         "\2\uffff\1\2\35\uffff\1\1";
19652     static final String DFA148_specialS =
19653         "\1\uffff\1\0\37\uffff}>";
19654     static final String[] DFA148_transitionS = {
19655             "\1\2\31\uffff\1\2\1\uffff\1\2\1\1\4\2\1\uffff\1\2\2\uffff\27"+
19656             "\2\1\uffff\3\2",
19657             "\1\uffff",
19658             "",
19659             "",
19660             "",
19661             "",
19662             "",
19663             "",
19664             "",
19665             "",
19666             "",
19667             "",
19668             "",
19669             "",
19670             "",
19671             "",
19672             "",
19673             "",
19674             "",
19675             "",
19676             "",
19677             "",
19678             "",
19679             "",
19680             "",
19681             "",
19682             "",
19683             "",
19684             "",
19685             "",
19686             "",
19687             "",
19688             ""
19689     };
19690 
19691     static final short[] DFA148_eot = DFA.unpackEncodedString(DFA148_eotS);
19692     static final short[] DFA148_eof = DFA.unpackEncodedString(DFA148_eofS);
19693     static final char[] DFA148_min = DFA.unpackEncodedStringToUnsignedChars(DFA148_minS);
19694     static final char[] DFA148_max = DFA.unpackEncodedStringToUnsignedChars(DFA148_maxS);
19695     static final short[] DFA148_accept = DFA.unpackEncodedString(DFA148_acceptS);
19696     static final short[] DFA148_special = DFA.unpackEncodedString(DFA148_specialS);
19697     static final short[][] DFA148_transition;
19698 
19699     static {
19700         int numStates = DFA148_transitionS.length;
19701         DFA148_transition = new short[numStates][];
19702         for (int i=0; i<numStates; i++) {
19703             DFA148_transition[i] = DFA.unpackEncodedString(DFA148_transitionS[i]);
19704         }
19705     }
19706 
19707     class DFA148 extends DFA {
19708 
DFA148(BaseRecognizer recognizer)19709         public DFA148(BaseRecognizer recognizer) {
19710             this.recognizer = recognizer;
19711             this.decisionNumber = 148;
19712             this.eot = DFA148_eot;
19713             this.eof = DFA148_eof;
19714             this.min = DFA148_min;
19715             this.max = DFA148_max;
19716             this.accept = DFA148_accept;
19717             this.special = DFA148_special;
19718             this.transition = DFA148_transition;
19719         }
getDescription()19720         public String getDescription() {
19721             return "()* loopback of 1176:9: ( '[' expression ']' )*";
19722         }
error(NoViableAltException nvae)19723         public void error(NoViableAltException nvae) {
19724             dbg.recognitionException(nvae);
19725         }
specialStateTransition(int s, IntStream _input)19726         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
19727             TokenStream input = (TokenStream)_input;
19728 		int _s = s;
19729             switch ( s ) {
19730                     case 0 :
19731                         int LA148_1 = input.LA(1);
19732 
19733 
19734                         int index148_1 = input.index();
19735                         input.rewind();
19736                         s = -1;
19737                         if ( (synpred240_Java()) ) {s = 32;}
19738 
19739                         else if ( (true) ) {s = 2;}
19740 
19741 
19742                         input.seek(index148_1);
19743                         if ( s>=0 ) return s;
19744                         break;
19745             }
19746             if (state.backtracking>0) {state.failed=true; return -1;}
19747             NoViableAltException nvae =
19748                 new NoViableAltException(getDescription(), 148, _s, input);
19749             error(nvae);
19750             throw nvae;
19751         }
19752     }
19753     static final String DFA171_eotS =
19754         "\55\uffff";
19755     static final String DFA171_eofS =
19756         "\55\uffff";
19757     static final String DFA171_minS =
19758         "\1\4\1\uffff\10\0\43\uffff";
19759     static final String DFA171_maxS =
19760         "\1\165\1\uffff\10\0\43\uffff";
19761     static final String DFA171_acceptS =
19762         "\1\uffff\1\1\10\uffff\1\2\42\uffff";
19763     static final String DFA171_specialS =
19764         "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\43\uffff}>";
19765     static final String[] DFA171_transitionS = {
19766             "\1\5\11\6\16\uffff\2\12\1\10\1\12\1\10\2\uffff\1\10\1\12\1\uffff"+
19767             "\1\12\1\uffff\1\12\1\10\1\uffff\1\12\1\uffff\1\12\1\uffff\1"+
19768             "\10\1\12\1\uffff\1\12\3\uffff\1\10\1\12\1\10\1\12\1\7\1\uffff"+
19769             "\4\12\1\10\2\12\1\4\2\12\1\2\1\12\1\uffff\2\12\1\11\2\12\1\3"+
19770             "\1\uffff\2\12\2\uffff\1\12\4\uffff\2\12\5\uffff\4\12\16\uffff"+
19771             "\1\12\2\uffff\1\1",
19772             "",
19773             "\1\uffff",
19774             "\1\uffff",
19775             "\1\uffff",
19776             "\1\uffff",
19777             "\1\uffff",
19778             "\1\uffff",
19779             "\1\uffff",
19780             "\1\uffff",
19781             "",
19782             "",
19783             "",
19784             "",
19785             "",
19786             "",
19787             "",
19788             "",
19789             "",
19790             "",
19791             "",
19792             "",
19793             "",
19794             "",
19795             "",
19796             "",
19797             "",
19798             "",
19799             "",
19800             "",
19801             "",
19802             "",
19803             "",
19804             "",
19805             "",
19806             "",
19807             "",
19808             "",
19809             "",
19810             "",
19811             "",
19812             "",
19813             "",
19814             "",
19815             ""
19816     };
19817 
19818     static final short[] DFA171_eot = DFA.unpackEncodedString(DFA171_eotS);
19819     static final short[] DFA171_eof = DFA.unpackEncodedString(DFA171_eofS);
19820     static final char[] DFA171_min = DFA.unpackEncodedStringToUnsignedChars(DFA171_minS);
19821     static final char[] DFA171_max = DFA.unpackEncodedStringToUnsignedChars(DFA171_maxS);
19822     static final short[] DFA171_accept = DFA.unpackEncodedString(DFA171_acceptS);
19823     static final short[] DFA171_special = DFA.unpackEncodedString(DFA171_specialS);
19824     static final short[][] DFA171_transition;
19825 
19826     static {
19827         int numStates = DFA171_transitionS.length;
19828         DFA171_transition = new short[numStates][];
19829         for (int i=0; i<numStates; i++) {
19830             DFA171_transition[i] = DFA.unpackEncodedString(DFA171_transitionS[i]);
19831         }
19832     }
19833 
19834     class DFA171 extends DFA {
19835 
DFA171(BaseRecognizer recognizer)19836         public DFA171(BaseRecognizer recognizer) {
19837             this.recognizer = recognizer;
19838             this.decisionNumber = 171;
19839             this.eot = DFA171_eot;
19840             this.eof = DFA171_eof;
19841             this.min = DFA171_min;
19842             this.max = DFA171_max;
19843             this.accept = DFA171_accept;
19844             this.special = DFA171_special;
19845             this.transition = DFA171_transition;
19846         }
getDescription()19847         public String getDescription() {
19848             return "521:9: ( explicitConstructorInvocation )?";
19849         }
error(NoViableAltException nvae)19850         public void error(NoViableAltException nvae) {
19851             dbg.recognitionException(nvae);
19852         }
specialStateTransition(int s, IntStream _input)19853         public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
19854             TokenStream input = (TokenStream)_input;
19855 		int _s = s;
19856             switch ( s ) {
19857                     case 0 :
19858                         int LA171_2 = input.LA(1);
19859 
19860 
19861                         int index171_2 = input.index();
19862                         input.rewind();
19863                         s = -1;
19864                         if ( (synpred57_Java()) ) {s = 1;}
19865 
19866                         else if ( (true) ) {s = 10;}
19867 
19868 
19869                         input.seek(index171_2);
19870                         if ( s>=0 ) return s;
19871                         break;
19872                     case 1 :
19873                         int LA171_3 = input.LA(1);
19874 
19875 
19876                         int index171_3 = input.index();
19877                         input.rewind();
19878                         s = -1;
19879                         if ( (synpred57_Java()) ) {s = 1;}
19880 
19881                         else if ( (true) ) {s = 10;}
19882 
19883 
19884                         input.seek(index171_3);
19885                         if ( s>=0 ) return s;
19886                         break;
19887                     case 2 :
19888                         int LA171_4 = input.LA(1);
19889 
19890 
19891                         int index171_4 = input.index();
19892                         input.rewind();
19893                         s = -1;
19894                         if ( (synpred57_Java()) ) {s = 1;}
19895 
19896                         else if ( (true) ) {s = 10;}
19897 
19898 
19899                         input.seek(index171_4);
19900                         if ( s>=0 ) return s;
19901                         break;
19902                     case 3 :
19903                         int LA171_5 = input.LA(1);
19904 
19905 
19906                         int index171_5 = input.index();
19907                         input.rewind();
19908                         s = -1;
19909                         if ( (synpred57_Java()) ) {s = 1;}
19910 
19911                         else if ( (true) ) {s = 10;}
19912 
19913 
19914                         input.seek(index171_5);
19915                         if ( s>=0 ) return s;
19916                         break;
19917                     case 4 :
19918                         int LA171_6 = input.LA(1);
19919 
19920 
19921                         int index171_6 = input.index();
19922                         input.rewind();
19923                         s = -1;
19924                         if ( (synpred57_Java()) ) {s = 1;}
19925 
19926                         else if ( (true) ) {s = 10;}
19927 
19928 
19929                         input.seek(index171_6);
19930                         if ( s>=0 ) return s;
19931                         break;
19932                     case 5 :
19933                         int LA171_7 = input.LA(1);
19934 
19935 
19936                         int index171_7 = input.index();
19937                         input.rewind();
19938                         s = -1;
19939                         if ( (synpred57_Java()) ) {s = 1;}
19940 
19941                         else if ( (true) ) {s = 10;}
19942 
19943 
19944                         input.seek(index171_7);
19945                         if ( s>=0 ) return s;
19946                         break;
19947                     case 6 :
19948                         int LA171_8 = input.LA(1);
19949 
19950 
19951                         int index171_8 = input.index();
19952                         input.rewind();
19953                         s = -1;
19954                         if ( (synpred57_Java()) ) {s = 1;}
19955 
19956                         else if ( (true) ) {s = 10;}
19957 
19958 
19959                         input.seek(index171_8);
19960                         if ( s>=0 ) return s;
19961                         break;
19962                     case 7 :
19963                         int LA171_9 = input.LA(1);
19964 
19965 
19966                         int index171_9 = input.index();
19967                         input.rewind();
19968                         s = -1;
19969                         if ( (synpred57_Java()) ) {s = 1;}
19970 
19971                         else if ( (true) ) {s = 10;}
19972 
19973 
19974                         input.seek(index171_9);
19975                         if ( s>=0 ) return s;
19976                         break;
19977             }
19978             if (state.backtracking>0) {state.failed=true; return -1;}
19979             NoViableAltException nvae =
19980                 new NoViableAltException(getDescription(), 171, _s, input);
19981             error(nvae);
19982             throw nvae;
19983         }
19984     }
19985 
19986 
19987     public static final BitSet FOLLOW_annotations_in_compilationUnit64 = new BitSet(new long[]{0x0800000000000000L});
19988     public static final BitSet FOLLOW_packageDeclaration_in_compilationUnit93 = new BitSet(new long[]{0x7290281010000002L,0x0004000000101226L});
19989     public static final BitSet FOLLOW_importDeclaration_in_compilationUnit115 = new BitSet(new long[]{0x7290281010000002L,0x0004000000101226L});
19990     public static final BitSet FOLLOW_typeDeclaration_in_compilationUnit137 = new BitSet(new long[]{0x7280281010000002L,0x0004000000101226L});
19991     public static final BitSet FOLLOW_PACKAGE_in_packageDeclaration167 = new BitSet(new long[]{0x0000000000000010L});
19992     public static final BitSet FOLLOW_qualifiedName_in_packageDeclaration169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
19993     public static final BitSet FOLLOW_SEMI_in_packageDeclaration179 = new BitSet(new long[]{0x0000000000000002L});
19994     public static final BitSet FOLLOW_IMPORT_in_importDeclaration198 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000002L});
19995     public static final BitSet FOLLOW_STATIC_in_importDeclaration209 = new BitSet(new long[]{0x0000000000000010L});
19996     public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration230 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
19997     public static final BitSet FOLLOW_DOT_in_importDeclaration232 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L});
19998     public static final BitSet FOLLOW_STAR_in_importDeclaration234 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
19999     public static final BitSet FOLLOW_SEMI_in_importDeclaration244 = new BitSet(new long[]{0x0000000000000002L});
20000     public static final BitSet FOLLOW_IMPORT_in_importDeclaration254 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000002L});
20001     public static final BitSet FOLLOW_STATIC_in_importDeclaration265 = new BitSet(new long[]{0x0000000000000010L});
20002     public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration286 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
20003     public static final BitSet FOLLOW_DOT_in_importDeclaration297 = new BitSet(new long[]{0x0000000000000010L});
20004     public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration299 = new BitSet(new long[]{0x0000000000000000L,0x0000000000500000L});
20005     public static final BitSet FOLLOW_DOT_in_importDeclaration321 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L});
20006     public static final BitSet FOLLOW_STAR_in_importDeclaration323 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20007     public static final BitSet FOLLOW_SEMI_in_importDeclaration344 = new BitSet(new long[]{0x0000000000000002L});
20008     public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName363 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
20009     public static final BitSet FOLLOW_DOT_in_qualifiedImportName374 = new BitSet(new long[]{0x0000000000000010L});
20010     public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName376 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
20011     public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration406 = new BitSet(new long[]{0x0000000000000002L});
20012     public static final BitSet FOLLOW_SEMI_in_typeDeclaration416 = new BitSet(new long[]{0x0000000000000002L});
20013     public static final BitSet FOLLOW_classDeclaration_in_classOrInterfaceDeclaration436 = new BitSet(new long[]{0x0000000000000002L});
20014     public static final BitSet FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration446 = new BitSet(new long[]{0x0000000000000002L});
20015     public static final BitSet FOLLOW_annotation_in_modifiers473 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20016     public static final BitSet FOLLOW_PUBLIC_in_modifiers483 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20017     public static final BitSet FOLLOW_PROTECTED_in_modifiers493 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20018     public static final BitSet FOLLOW_PRIVATE_in_modifiers503 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20019     public static final BitSet FOLLOW_STATIC_in_modifiers513 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20020     public static final BitSet FOLLOW_ABSTRACT_in_modifiers523 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20021     public static final BitSet FOLLOW_FINAL_in_modifiers533 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20022     public static final BitSet FOLLOW_NATIVE_in_modifiers543 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20023     public static final BitSet FOLLOW_SYNCHRONIZED_in_modifiers553 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20024     public static final BitSet FOLLOW_TRANSIENT_in_modifiers563 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20025     public static final BitSet FOLLOW_VOLATILE_in_modifiers573 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20026     public static final BitSet FOLLOW_STRICTFP_in_modifiers583 = new BitSet(new long[]{0x7200200010000002L,0x0004000000001226L});
20027     public static final BitSet FOLLOW_FINAL_in_variableModifiers614 = new BitSet(new long[]{0x0000200000000002L,0x0004000000000000L});
20028     public static final BitSet FOLLOW_annotation_in_variableModifiers628 = new BitSet(new long[]{0x0000200000000002L,0x0004000000000000L});
20029     public static final BitSet FOLLOW_normalClassDeclaration_in_classDeclaration659 = new BitSet(new long[]{0x0000000000000002L});
20030     public static final BitSet FOLLOW_enumDeclaration_in_classDeclaration669 = new BitSet(new long[]{0x0000000000000002L});
20031     public static final BitSet FOLLOW_modifiers_in_normalClassDeclaration688 = new BitSet(new long[]{0x0000001000000000L});
20032     public static final BitSet FOLLOW_CLASS_in_normalClassDeclaration691 = new BitSet(new long[]{0x0000000000000010L});
20033     public static final BitSet FOLLOW_IDENTIFIER_in_normalClassDeclaration693 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L});
20034     public static final BitSet FOLLOW_typeParameters_in_normalClassDeclaration704 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L});
20035     public static final BitSet FOLLOW_EXTENDS_in_normalClassDeclaration726 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20036     public static final BitSet FOLLOW_type_in_normalClassDeclaration728 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L});
20037     public static final BitSet FOLLOW_IMPLEMENTS_in_normalClassDeclaration750 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20038     public static final BitSet FOLLOW_typeList_in_normalClassDeclaration752 = new BitSet(new long[]{0x0008100000000000L,0x0020000000010000L});
20039     public static final BitSet FOLLOW_classBody_in_normalClassDeclaration773 = new BitSet(new long[]{0x0000000000000002L});
20040     public static final BitSet FOLLOW_LT_in_typeParameters793 = new BitSet(new long[]{0x0000000000000010L});
20041     public static final BitSet FOLLOW_typeParameter_in_typeParameters807 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L});
20042     public static final BitSet FOLLOW_COMMA_in_typeParameters822 = new BitSet(new long[]{0x0000000000000010L});
20043     public static final BitSet FOLLOW_typeParameter_in_typeParameters824 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L});
20044     public static final BitSet FOLLOW_GT_in_typeParameters849 = new BitSet(new long[]{0x0000000000000002L});
20045     public static final BitSet FOLLOW_IDENTIFIER_in_typeParameter868 = new BitSet(new long[]{0x0000100000000002L});
20046     public static final BitSet FOLLOW_EXTENDS_in_typeParameter879 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20047     public static final BitSet FOLLOW_typeBound_in_typeParameter881 = new BitSet(new long[]{0x0000000000000002L});
20048     public static final BitSet FOLLOW_type_in_typeBound912 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L});
20049     public static final BitSet FOLLOW_AMP_in_typeBound923 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20050     public static final BitSet FOLLOW_type_in_typeBound925 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L});
20051     public static final BitSet FOLLOW_modifiers_in_enumDeclaration956 = new BitSet(new long[]{0x0000080000000000L});
20052     public static final BitSet FOLLOW_ENUM_in_enumDeclaration967 = new BitSet(new long[]{0x0000000000000010L});
20053     public static final BitSet FOLLOW_IDENTIFIER_in_enumDeclaration987 = new BitSet(new long[]{0x0008000000000000L,0x0000000000010000L});
20054     public static final BitSet FOLLOW_IMPLEMENTS_in_enumDeclaration998 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20055     public static final BitSet FOLLOW_typeList_in_enumDeclaration1000 = new BitSet(new long[]{0x0008000000000000L,0x0000000000010000L});
20056     public static final BitSet FOLLOW_enumBody_in_enumDeclaration1021 = new BitSet(new long[]{0x0000000000000002L});
20057     public static final BitSet FOLLOW_LBRACE_in_enumBody1041 = new BitSet(new long[]{0x0000000000000010L,0x0004000000320000L});
20058     public static final BitSet FOLLOW_enumConstants_in_enumBody1052 = new BitSet(new long[]{0x0000000000000000L,0x0000000000320000L});
20059     public static final BitSet FOLLOW_COMMA_in_enumBody1073 = new BitSet(new long[]{0x0000000000000000L,0x0000000000120000L});
20060     public static final BitSet FOLLOW_enumBodyDeclarations_in_enumBody1085 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
20061     public static final BitSet FOLLOW_RBRACE_in_enumBody1106 = new BitSet(new long[]{0x0000000000000002L});
20062     public static final BitSet FOLLOW_enumConstant_in_enumConstants1125 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20063     public static final BitSet FOLLOW_COMMA_in_enumConstants1136 = new BitSet(new long[]{0x0000000000000010L,0x0004000000000000L});
20064     public static final BitSet FOLLOW_enumConstant_in_enumConstants1138 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20065     public static final BitSet FOLLOW_annotations_in_enumConstant1171 = new BitSet(new long[]{0x0000000000000010L});
20066     public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant1192 = new BitSet(new long[]{0x0008100000000002L,0x0020000000014000L});
20067     public static final BitSet FOLLOW_arguments_in_enumConstant1203 = new BitSet(new long[]{0x0008100000000002L,0x0020000000010000L});
20068     public static final BitSet FOLLOW_classBody_in_enumConstant1225 = new BitSet(new long[]{0x0000000000000002L});
20069     public static final BitSet FOLLOW_SEMI_in_enumBodyDeclarations1265 = new BitSet(new long[]{0x73C0AA1950000012L,0x0024000000111A27L});
20070     public static final BitSet FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1276 = new BitSet(new long[]{0x73C0AA1950000012L,0x0024000000111A27L});
20071     public static final BitSet FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1306 = new BitSet(new long[]{0x0000000000000002L});
20072     public static final BitSet FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1316 = new BitSet(new long[]{0x0000000000000002L});
20073     public static final BitSet FOLLOW_modifiers_in_normalInterfaceDeclaration1335 = new BitSet(new long[]{0x0080000000000000L});
20074     public static final BitSet FOLLOW_INTERFACE_in_normalInterfaceDeclaration1337 = new BitSet(new long[]{0x0000000000000010L});
20075     public static final BitSet FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1339 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L});
20076     public static final BitSet FOLLOW_typeParameters_in_normalInterfaceDeclaration1350 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L});
20077     public static final BitSet FOLLOW_EXTENDS_in_normalInterfaceDeclaration1372 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20078     public static final BitSet FOLLOW_typeList_in_normalInterfaceDeclaration1374 = new BitSet(new long[]{0x0000100000000000L,0x0020000000010000L});
20079     public static final BitSet FOLLOW_interfaceBody_in_normalInterfaceDeclaration1395 = new BitSet(new long[]{0x0000000000000002L});
20080     public static final BitSet FOLLOW_type_in_typeList1414 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20081     public static final BitSet FOLLOW_COMMA_in_typeList1425 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20082     public static final BitSet FOLLOW_type_in_typeList1427 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20083     public static final BitSet FOLLOW_LBRACE_in_classBody1457 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000131A27L});
20084     public static final BitSet FOLLOW_classBodyDeclaration_in_classBody1468 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000131A27L});
20085     public static final BitSet FOLLOW_RBRACE_in_classBody1489 = new BitSet(new long[]{0x0000000000000002L});
20086     public static final BitSet FOLLOW_LBRACE_in_interfaceBody1508 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000121A27L});
20087     public static final BitSet FOLLOW_interfaceBodyDeclaration_in_interfaceBody1519 = new BitSet(new long[]{0x73C0AA1950000010L,0x0024000000121A27L});
20088     public static final BitSet FOLLOW_RBRACE_in_interfaceBody1540 = new BitSet(new long[]{0x0000000000000002L});
20089     public static final BitSet FOLLOW_SEMI_in_classBodyDeclaration1559 = new BitSet(new long[]{0x0000000000000002L});
20090     public static final BitSet FOLLOW_STATIC_in_classBodyDeclaration1570 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L});
20091     public static final BitSet FOLLOW_block_in_classBodyDeclaration1591 = new BitSet(new long[]{0x0000000000000002L});
20092     public static final BitSet FOLLOW_memberDecl_in_classBodyDeclaration1601 = new BitSet(new long[]{0x0000000000000002L});
20093     public static final BitSet FOLLOW_fieldDeclaration_in_memberDecl1621 = new BitSet(new long[]{0x0000000000000002L});
20094     public static final BitSet FOLLOW_methodDeclaration_in_memberDecl1632 = new BitSet(new long[]{0x0000000000000002L});
20095     public static final BitSet FOLLOW_classDeclaration_in_memberDecl1643 = new BitSet(new long[]{0x0000000000000002L});
20096     public static final BitSet FOLLOW_interfaceDeclaration_in_memberDecl1654 = new BitSet(new long[]{0x0000000000000002L});
20097     public static final BitSet FOLLOW_modifiers_in_methodDeclaration1691 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L});
20098     public static final BitSet FOLLOW_typeParameters_in_methodDeclaration1702 = new BitSet(new long[]{0x0000000000000010L});
20099     public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration1723 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20100     public static final BitSet FOLLOW_formalParameters_in_methodDeclaration1733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010100L});
20101     public static final BitSet FOLLOW_THROWS_in_methodDeclaration1744 = new BitSet(new long[]{0x0000000000000010L});
20102     public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration1746 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
20103     public static final BitSet FOLLOW_LBRACE_in_methodDeclaration1767 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL});
20104     public static final BitSet FOLLOW_explicitConstructorInvocation_in_methodDeclaration1778 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL});
20105     public static final BitSet FOLLOW_blockStatement_in_methodDeclaration1800 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL});
20106     public static final BitSet FOLLOW_RBRACE_in_methodDeclaration1821 = new BitSet(new long[]{0x0000000000000002L});
20107     public static final BitSet FOLLOW_modifiers_in_methodDeclaration1831 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L});
20108     public static final BitSet FOLLOW_typeParameters_in_methodDeclaration1842 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L});
20109     public static final BitSet FOLLOW_type_in_methodDeclaration1864 = new BitSet(new long[]{0x0000000000000010L});
20110     public static final BitSet FOLLOW_VOID_in_methodDeclaration1878 = new BitSet(new long[]{0x0000000000000010L});
20111     public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration1898 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20112     public static final BitSet FOLLOW_formalParameters_in_methodDeclaration1908 = new BitSet(new long[]{0x0000000000000000L,0x0000000000150102L});
20113     public static final BitSet FOLLOW_LBRACKET_in_methodDeclaration1919 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20114     public static final BitSet FOLLOW_RBRACKET_in_methodDeclaration1921 = new BitSet(new long[]{0x0000000000000000L,0x0000000000150102L});
20115     public static final BitSet FOLLOW_THROWS_in_methodDeclaration1943 = new BitSet(new long[]{0x0000000000000010L});
20116     public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration1945 = new BitSet(new long[]{0x0000000000000000L,0x0000000000110002L});
20117     public static final BitSet FOLLOW_block_in_methodDeclaration1980 = new BitSet(new long[]{0x0000000000000002L});
20118     public static final BitSet FOLLOW_SEMI_in_methodDeclaration1994 = new BitSet(new long[]{0x0000000000000002L});
20119     public static final BitSet FOLLOW_modifiers_in_fieldDeclaration2024 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20120     public static final BitSet FOLLOW_type_in_fieldDeclaration2034 = new BitSet(new long[]{0x0000000000000010L});
20121     public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2044 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L});
20122     public static final BitSet FOLLOW_COMMA_in_fieldDeclaration2055 = new BitSet(new long[]{0x0000000000000010L});
20123     public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2057 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L});
20124     public static final BitSet FOLLOW_SEMI_in_fieldDeclaration2078 = new BitSet(new long[]{0x0000000000000002L});
20125     public static final BitSet FOLLOW_IDENTIFIER_in_variableDeclarator2097 = new BitSet(new long[]{0x0000000000000002L,0x0000000001040000L});
20126     public static final BitSet FOLLOW_LBRACKET_in_variableDeclarator2108 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20127     public static final BitSet FOLLOW_RBRACKET_in_variableDeclarator2110 = new BitSet(new long[]{0x0000000000000002L,0x0000000001040000L});
20128     public static final BitSet FOLLOW_EQ_in_variableDeclarator2132 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06014849L});
20129     public static final BitSet FOLLOW_variableInitializer_in_variableDeclarator2134 = new BitSet(new long[]{0x0000000000000002L});
20130     public static final BitSet FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2172 = new BitSet(new long[]{0x0000000000000002L});
20131     public static final BitSet FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2182 = new BitSet(new long[]{0x0000000000000002L});
20132     public static final BitSet FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2192 = new BitSet(new long[]{0x0000000000000002L});
20133     public static final BitSet FOLLOW_classDeclaration_in_interfaceBodyDeclaration2202 = new BitSet(new long[]{0x0000000000000002L});
20134     public static final BitSet FOLLOW_SEMI_in_interfaceBodyDeclaration2212 = new BitSet(new long[]{0x0000000000000002L});
20135     public static final BitSet FOLLOW_modifiers_in_interfaceMethodDeclaration2231 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L});
20136     public static final BitSet FOLLOW_typeParameters_in_interfaceMethodDeclaration2242 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L});
20137     public static final BitSet FOLLOW_type_in_interfaceMethodDeclaration2264 = new BitSet(new long[]{0x0000000000000010L});
20138     public static final BitSet FOLLOW_VOID_in_interfaceMethodDeclaration2275 = new BitSet(new long[]{0x0000000000000010L});
20139     public static final BitSet FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2295 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20140     public static final BitSet FOLLOW_formalParameters_in_interfaceMethodDeclaration2305 = new BitSet(new long[]{0x0000000000000000L,0x0000000000140100L});
20141     public static final BitSet FOLLOW_LBRACKET_in_interfaceMethodDeclaration2316 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20142     public static final BitSet FOLLOW_RBRACKET_in_interfaceMethodDeclaration2318 = new BitSet(new long[]{0x0000000000000000L,0x0000000000140100L});
20143     public static final BitSet FOLLOW_THROWS_in_interfaceMethodDeclaration2340 = new BitSet(new long[]{0x0000000000000010L});
20144     public static final BitSet FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2342 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20145     public static final BitSet FOLLOW_SEMI_in_interfaceMethodDeclaration2355 = new BitSet(new long[]{0x0000000000000002L});
20146     public static final BitSet FOLLOW_modifiers_in_interfaceFieldDeclaration2376 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20147     public static final BitSet FOLLOW_type_in_interfaceFieldDeclaration2378 = new BitSet(new long[]{0x0000000000000010L});
20148     public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L});
20149     public static final BitSet FOLLOW_COMMA_in_interfaceFieldDeclaration2391 = new BitSet(new long[]{0x0000000000000010L});
20150     public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2393 = new BitSet(new long[]{0x0000000000000000L,0x0000000000300000L});
20151     public static final BitSet FOLLOW_SEMI_in_interfaceFieldDeclaration2414 = new BitSet(new long[]{0x0000000000000002L});
20152     public static final BitSet FOLLOW_classOrInterfaceType_in_type2434 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20153     public static final BitSet FOLLOW_LBRACKET_in_type2445 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20154     public static final BitSet FOLLOW_RBRACKET_in_type2447 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20155     public static final BitSet FOLLOW_primitiveType_in_type2468 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20156     public static final BitSet FOLLOW_LBRACKET_in_type2479 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20157     public static final BitSet FOLLOW_RBRACKET_in_type2481 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20158     public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType2512 = new BitSet(new long[]{0x0000000000000002L,0x0020000000400000L});
20159     public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType2523 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
20160     public static final BitSet FOLLOW_DOT_in_classOrInterfaceType2545 = new BitSet(new long[]{0x0000000000000010L});
20161     public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType2547 = new BitSet(new long[]{0x0000000000000002L,0x0020000000400000L});
20162     public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType2562 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
20163     public static final BitSet FOLLOW_set_in_primitiveType0 = new BitSet(new long[]{0x0000000000000002L});
20164     public static final BitSet FOLLOW_LT_in_typeArguments2696 = new BitSet(new long[]{0x0140820940000010L,0x0000000008000001L});
20165     public static final BitSet FOLLOW_typeArgument_in_typeArguments2698 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L});
20166     public static final BitSet FOLLOW_COMMA_in_typeArguments2709 = new BitSet(new long[]{0x0140820940000010L,0x0000000008000001L});
20167     public static final BitSet FOLLOW_typeArgument_in_typeArguments2711 = new BitSet(new long[]{0x0000000000000000L,0x0010000000200000L});
20168     public static final BitSet FOLLOW_GT_in_typeArguments2732 = new BitSet(new long[]{0x0000000000000002L});
20169     public static final BitSet FOLLOW_type_in_typeArgument2751 = new BitSet(new long[]{0x0000000000000002L});
20170     public static final BitSet FOLLOW_QUES_in_typeArgument2761 = new BitSet(new long[]{0x0000100000000002L,0x0000000000000008L});
20171     public static final BitSet FOLLOW_set_in_typeArgument2785 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20172     public static final BitSet FOLLOW_type_in_typeArgument2829 = new BitSet(new long[]{0x0000000000000002L});
20173     public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList2859 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20174     public static final BitSet FOLLOW_COMMA_in_qualifiedNameList2870 = new BitSet(new long[]{0x0000000000000010L});
20175     public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList2872 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20176     public static final BitSet FOLLOW_LPAREN_in_formalParameters2902 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000008001L});
20177     public static final BitSet FOLLOW_formalParameterDecls_in_formalParameters2913 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20178     public static final BitSet FOLLOW_RPAREN_in_formalParameters2934 = new BitSet(new long[]{0x0000000000000002L});
20179     public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls2953 = new BitSet(new long[]{0x0000000000000002L});
20180     public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2963 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20181     public static final BitSet FOLLOW_COMMA_in_formalParameterDecls2974 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L});
20182     public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2976 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20183     public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls2998 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
20184     public static final BitSet FOLLOW_COMMA_in_formalParameterDecls3008 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L});
20185     public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3029 = new BitSet(new long[]{0x0000000000000002L});
20186     public static final BitSet FOLLOW_variableModifiers_in_normalParameterDecl3048 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20187     public static final BitSet FOLLOW_type_in_normalParameterDecl3050 = new BitSet(new long[]{0x0000000000000010L});
20188     public static final BitSet FOLLOW_IDENTIFIER_in_normalParameterDecl3052 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20189     public static final BitSet FOLLOW_LBRACKET_in_normalParameterDecl3063 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20190     public static final BitSet FOLLOW_RBRACKET_in_normalParameterDecl3065 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20191     public static final BitSet FOLLOW_variableModifiers_in_ellipsisParameterDecl3095 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20192     public static final BitSet FOLLOW_type_in_ellipsisParameterDecl3105 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
20193     public static final BitSet FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3108 = new BitSet(new long[]{0x0000000000000010L});
20194     public static final BitSet FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3118 = new BitSet(new long[]{0x0000000000000002L});
20195     public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000048L});
20196     public static final BitSet FOLLOW_set_in_explicitConstructorInvocation3165 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20197     public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation3197 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20198     public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation3199 = new BitSet(new long[]{0x0000000000000002L});
20199     public static final BitSet FOLLOW_primary_in_explicitConstructorInvocation3210 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
20200     public static final BitSet FOLLOW_DOT_in_explicitConstructorInvocation3220 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000008L});
20201     public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3231 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
20202     public static final BitSet FOLLOW_SUPER_in_explicitConstructorInvocation3252 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20203     public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation3262 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20204     public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation3264 = new BitSet(new long[]{0x0000000000000002L});
20205     public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName3283 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
20206     public static final BitSet FOLLOW_DOT_in_qualifiedName3294 = new BitSet(new long[]{0x0000000000000010L});
20207     public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName3296 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
20208     public static final BitSet FOLLOW_annotation_in_annotations3327 = new BitSet(new long[]{0x0000000000000002L,0x0004000000000000L});
20209     public static final BitSet FOLLOW_MONKEYS_AT_in_annotation3359 = new BitSet(new long[]{0x0000000000000010L});
20210     public static final BitSet FOLLOW_qualifiedName_in_annotation3361 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
20211     public static final BitSet FOLLOW_LPAREN_in_annotation3375 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F0601C849L});
20212     public static final BitSet FOLLOW_elementValuePairs_in_annotation3399 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20213     public static final BitSet FOLLOW_elementValue_in_annotation3423 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20214     public static final BitSet FOLLOW_RPAREN_in_annotation3458 = new BitSet(new long[]{0x0000000000000002L});
20215     public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs3488 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20216     public static final BitSet FOLLOW_COMMA_in_elementValuePairs3499 = new BitSet(new long[]{0x0000000000000010L});
20217     public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs3501 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20218     public static final BitSet FOLLOW_IDENTIFIER_in_elementValuePair3531 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
20219     public static final BitSet FOLLOW_EQ_in_elementValuePair3533 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L});
20220     public static final BitSet FOLLOW_elementValue_in_elementValuePair3535 = new BitSet(new long[]{0x0000000000000002L});
20221     public static final BitSet FOLLOW_conditionalExpression_in_elementValue3554 = new BitSet(new long[]{0x0000000000000002L});
20222     public static final BitSet FOLLOW_annotation_in_elementValue3564 = new BitSet(new long[]{0x0000000000000002L});
20223     public static final BitSet FOLLOW_elementValueArrayInitializer_in_elementValue3574 = new BitSet(new long[]{0x0000000000000002L});
20224     public static final BitSet FOLLOW_LBRACE_in_elementValueArrayInitializer3593 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06234849L});
20225     public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer3604 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L});
20226     public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer3619 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L});
20227     public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer3621 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L});
20228     public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer3650 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
20229     public static final BitSet FOLLOW_RBRACE_in_elementValueArrayInitializer3654 = new BitSet(new long[]{0x0000000000000002L});
20230     public static final BitSet FOLLOW_modifiers_in_annotationTypeDeclaration3676 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L});
20231     public static final BitSet FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration3678 = new BitSet(new long[]{0x0080000000000000L});
20232     public static final BitSet FOLLOW_INTERFACE_in_annotationTypeDeclaration3688 = new BitSet(new long[]{0x0000000000000010L});
20233     public static final BitSet FOLLOW_IDENTIFIER_in_annotationTypeDeclaration3698 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
20234     public static final BitSet FOLLOW_annotationTypeBody_in_annotationTypeDeclaration3708 = new BitSet(new long[]{0x0000000000000002L});
20235     public static final BitSet FOLLOW_LBRACE_in_annotationTypeBody3728 = new BitSet(new long[]{0x73C0AA1950000010L,0x0004000000121227L});
20236     public static final BitSet FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody3739 = new BitSet(new long[]{0x73C0AA1950000010L,0x0004000000121227L});
20237     public static final BitSet FOLLOW_RBRACE_in_annotationTypeBody3760 = new BitSet(new long[]{0x0000000000000002L});
20238     public static final BitSet FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration3781 = new BitSet(new long[]{0x0000000000000002L});
20239     public static final BitSet FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration3791 = new BitSet(new long[]{0x0000000000000002L});
20240     public static final BitSet FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration3801 = new BitSet(new long[]{0x0000000000000002L});
20241     public static final BitSet FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration3811 = new BitSet(new long[]{0x0000000000000002L});
20242     public static final BitSet FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration3821 = new BitSet(new long[]{0x0000000000000002L});
20243     public static final BitSet FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration3831 = new BitSet(new long[]{0x0000000000000002L});
20244     public static final BitSet FOLLOW_SEMI_in_annotationTypeElementDeclaration3841 = new BitSet(new long[]{0x0000000000000002L});
20245     public static final BitSet FOLLOW_modifiers_in_annotationMethodDeclaration3860 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20246     public static final BitSet FOLLOW_type_in_annotationMethodDeclaration3862 = new BitSet(new long[]{0x0000000000000010L});
20247     public static final BitSet FOLLOW_IDENTIFIER_in_annotationMethodDeclaration3864 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20248     public static final BitSet FOLLOW_LPAREN_in_annotationMethodDeclaration3874 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20249     public static final BitSet FOLLOW_RPAREN_in_annotationMethodDeclaration3876 = new BitSet(new long[]{0x0000008000000000L,0x0000000000100000L});
20250     public static final BitSet FOLLOW_DEFAULT_in_annotationMethodDeclaration3879 = new BitSet(new long[]{0x0540820940003FF0L,0x0024000F06014849L});
20251     public static final BitSet FOLLOW_elementValue_in_annotationMethodDeclaration3881 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20252     public static final BitSet FOLLOW_SEMI_in_annotationMethodDeclaration3910 = new BitSet(new long[]{0x0000000000000002L});
20253     public static final BitSet FOLLOW_LBRACE_in_block3933 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL});
20254     public static final BitSet FOLLOW_blockStatement_in_block3944 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL});
20255     public static final BitSet FOLLOW_RBRACE_in_block3965 = new BitSet(new long[]{0x0000000000000002L});
20256     public static final BitSet FOLLOW_localVariableDeclarationStatement_in_blockStatement3986 = new BitSet(new long[]{0x0000000000000002L});
20257     public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_blockStatement3996 = new BitSet(new long[]{0x0000000000000002L});
20258     public static final BitSet FOLLOW_statement_in_blockStatement4006 = new BitSet(new long[]{0x0000000000000002L});
20259     public static final BitSet FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4026 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20260     public static final BitSet FOLLOW_SEMI_in_localVariableDeclarationStatement4036 = new BitSet(new long[]{0x0000000000000002L});
20261     public static final BitSet FOLLOW_variableModifiers_in_localVariableDeclaration4055 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20262     public static final BitSet FOLLOW_type_in_localVariableDeclaration4057 = new BitSet(new long[]{0x0000000000000010L});
20263     public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration4067 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20264     public static final BitSet FOLLOW_COMMA_in_localVariableDeclaration4078 = new BitSet(new long[]{0x0000000000000010L});
20265     public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration4080 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20266     public static final BitSet FOLLOW_block_in_statement4110 = new BitSet(new long[]{0x0000000000000002L});
20267     public static final BitSet FOLLOW_ASSERT_in_statement4122 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20268     public static final BitSet FOLLOW_expression_in_statement4142 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L});
20269     public static final BitSet FOLLOW_COLON_in_statement4145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20270     public static final BitSet FOLLOW_expression_in_statement4147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20271     public static final BitSet FOLLOW_SEMI_in_statement4151 = new BitSet(new long[]{0x0000000000000002L});
20272     public static final BitSet FOLLOW_ASSERT_in_statement4161 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20273     public static final BitSet FOLLOW_expression_in_statement4164 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L});
20274     public static final BitSet FOLLOW_COLON_in_statement4167 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20275     public static final BitSet FOLLOW_expression_in_statement4169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20276     public static final BitSet FOLLOW_SEMI_in_statement4173 = new BitSet(new long[]{0x0000000000000002L});
20277     public static final BitSet FOLLOW_IF_in_statement4183 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20278     public static final BitSet FOLLOW_parExpression_in_statement4185 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20279     public static final BitSet FOLLOW_statement_in_statement4187 = new BitSet(new long[]{0x0000040000000002L});
20280     public static final BitSet FOLLOW_ELSE_in_statement4190 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20281     public static final BitSet FOLLOW_statement_in_statement4192 = new BitSet(new long[]{0x0000000000000002L});
20282     public static final BitSet FOLLOW_forstatement_in_statement4204 = new BitSet(new long[]{0x0000000000000002L});
20283     public static final BitSet FOLLOW_WHILE_in_statement4214 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20284     public static final BitSet FOLLOW_parExpression_in_statement4216 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20285     public static final BitSet FOLLOW_statement_in_statement4218 = new BitSet(new long[]{0x0000000000000002L});
20286     public static final BitSet FOLLOW_DO_in_statement4228 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20287     public static final BitSet FOLLOW_statement_in_statement4230 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
20288     public static final BitSet FOLLOW_WHILE_in_statement4232 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20289     public static final BitSet FOLLOW_parExpression_in_statement4234 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20290     public static final BitSet FOLLOW_SEMI_in_statement4236 = new BitSet(new long[]{0x0000000000000002L});
20291     public static final BitSet FOLLOW_trystatement_in_statement4246 = new BitSet(new long[]{0x0000000000000002L});
20292     public static final BitSet FOLLOW_SWITCH_in_statement4256 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20293     public static final BitSet FOLLOW_parExpression_in_statement4258 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
20294     public static final BitSet FOLLOW_LBRACE_in_statement4260 = new BitSet(new long[]{0x0000008200000000L,0x0000000000020000L});
20295     public static final BitSet FOLLOW_switchBlockStatementGroups_in_statement4262 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
20296     public static final BitSet FOLLOW_RBRACE_in_statement4264 = new BitSet(new long[]{0x0000000000000002L});
20297     public static final BitSet FOLLOW_SYNCHRONIZED_in_statement4274 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20298     public static final BitSet FOLLOW_parExpression_in_statement4276 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L});
20299     public static final BitSet FOLLOW_block_in_statement4278 = new BitSet(new long[]{0x0000000000000002L});
20300     public static final BitSet FOLLOW_RETURN_in_statement4288 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06104849L});
20301     public static final BitSet FOLLOW_expression_in_statement4291 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20302     public static final BitSet FOLLOW_SEMI_in_statement4296 = new BitSet(new long[]{0x0000000000000002L});
20303     public static final BitSet FOLLOW_THROW_in_statement4306 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20304     public static final BitSet FOLLOW_expression_in_statement4308 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20305     public static final BitSet FOLLOW_SEMI_in_statement4310 = new BitSet(new long[]{0x0000000000000002L});
20306     public static final BitSet FOLLOW_BREAK_in_statement4320 = new BitSet(new long[]{0x0000000000000010L,0x0000000000100000L});
20307     public static final BitSet FOLLOW_IDENTIFIER_in_statement4335 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20308     public static final BitSet FOLLOW_SEMI_in_statement4352 = new BitSet(new long[]{0x0000000000000002L});
20309     public static final BitSet FOLLOW_CONTINUE_in_statement4362 = new BitSet(new long[]{0x0000000000000010L,0x0000000000100000L});
20310     public static final BitSet FOLLOW_IDENTIFIER_in_statement4377 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20311     public static final BitSet FOLLOW_SEMI_in_statement4394 = new BitSet(new long[]{0x0000000000000002L});
20312     public static final BitSet FOLLOW_expression_in_statement4404 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20313     public static final BitSet FOLLOW_SEMI_in_statement4407 = new BitSet(new long[]{0x0000000000000002L});
20314     public static final BitSet FOLLOW_IDENTIFIER_in_statement4417 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
20315     public static final BitSet FOLLOW_COLON_in_statement4419 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20316     public static final BitSet FOLLOW_statement_in_statement4421 = new BitSet(new long[]{0x0000000000000002L});
20317     public static final BitSet FOLLOW_SEMI_in_statement4431 = new BitSet(new long[]{0x0000000000000002L});
20318     public static final BitSet FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups4452 = new BitSet(new long[]{0x0000008200000002L});
20319     public static final BitSet FOLLOW_switchLabel_in_switchBlockStatementGroup4480 = new BitSet(new long[]{0xF7C5AB59F0003FF2L,0x0024000F06117EFFL});
20320     public static final BitSet FOLLOW_blockStatement_in_switchBlockStatementGroup4491 = new BitSet(new long[]{0xF7C5AB59F0003FF2L,0x0024000F06117EFFL});
20321     public static final BitSet FOLLOW_CASE_in_switchLabel4521 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20322     public static final BitSet FOLLOW_expression_in_switchLabel4523 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
20323     public static final BitSet FOLLOW_COLON_in_switchLabel4525 = new BitSet(new long[]{0x0000000000000002L});
20324     public static final BitSet FOLLOW_DEFAULT_in_switchLabel4535 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
20325     public static final BitSet FOLLOW_COLON_in_switchLabel4537 = new BitSet(new long[]{0x0000000000000002L});
20326     public static final BitSet FOLLOW_TRY_in_trystatement4557 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L});
20327     public static final BitSet FOLLOW_block_in_trystatement4559 = new BitSet(new long[]{0x0000400400000000L});
20328     public static final BitSet FOLLOW_catches_in_trystatement4573 = new BitSet(new long[]{0x0000400000000000L});
20329     public static final BitSet FOLLOW_FINALLY_in_trystatement4575 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L});
20330     public static final BitSet FOLLOW_block_in_trystatement4577 = new BitSet(new long[]{0x0000000000000002L});
20331     public static final BitSet FOLLOW_catches_in_trystatement4591 = new BitSet(new long[]{0x0000000000000002L});
20332     public static final BitSet FOLLOW_FINALLY_in_trystatement4605 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L});
20333     public static final BitSet FOLLOW_block_in_trystatement4607 = new BitSet(new long[]{0x0000000000000002L});
20334     public static final BitSet FOLLOW_catchClause_in_catches4637 = new BitSet(new long[]{0x0000000400000002L});
20335     public static final BitSet FOLLOW_catchClause_in_catches4648 = new BitSet(new long[]{0x0000000400000002L});
20336     public static final BitSet FOLLOW_CATCH_in_catchClause4678 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20337     public static final BitSet FOLLOW_LPAREN_in_catchClause4680 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L});
20338     public static final BitSet FOLLOW_formalParameter_in_catchClause4682 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20339     public static final BitSet FOLLOW_RPAREN_in_catchClause4692 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L});
20340     public static final BitSet FOLLOW_block_in_catchClause4694 = new BitSet(new long[]{0x0000000000000002L});
20341     public static final BitSet FOLLOW_variableModifiers_in_formalParameter4713 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20342     public static final BitSet FOLLOW_type_in_formalParameter4715 = new BitSet(new long[]{0x0000000000000010L});
20343     public static final BitSet FOLLOW_IDENTIFIER_in_formalParameter4717 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20344     public static final BitSet FOLLOW_LBRACKET_in_formalParameter4728 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20345     public static final BitSet FOLLOW_RBRACKET_in_formalParameter4730 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20346     public static final BitSet FOLLOW_FOR_in_forstatement4775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20347     public static final BitSet FOLLOW_LPAREN_in_forstatement4777 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L});
20348     public static final BitSet FOLLOW_variableModifiers_in_forstatement4779 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20349     public static final BitSet FOLLOW_type_in_forstatement4781 = new BitSet(new long[]{0x0000000000000010L});
20350     public static final BitSet FOLLOW_IDENTIFIER_in_forstatement4783 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
20351     public static final BitSet FOLLOW_COLON_in_forstatement4785 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20352     public static final BitSet FOLLOW_expression_in_forstatement4795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20353     public static final BitSet FOLLOW_RPAREN_in_forstatement4797 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20354     public static final BitSet FOLLOW_statement_in_forstatement4799 = new BitSet(new long[]{0x0000000000000002L});
20355     public static final BitSet FOLLOW_FOR_in_forstatement4819 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20356     public static final BitSet FOLLOW_LPAREN_in_forstatement4821 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F06104849L});
20357     public static final BitSet FOLLOW_forInit_in_forstatement4840 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20358     public static final BitSet FOLLOW_SEMI_in_forstatement4861 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06104849L});
20359     public static final BitSet FOLLOW_expression_in_forstatement4880 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20360     public static final BitSet FOLLOW_SEMI_in_forstatement4901 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F0600C849L});
20361     public static final BitSet FOLLOW_expressionList_in_forstatement4920 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20362     public static final BitSet FOLLOW_RPAREN_in_forstatement4941 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20363     public static final BitSet FOLLOW_statement_in_forstatement4943 = new BitSet(new long[]{0x0000000000000002L});
20364     public static final BitSet FOLLOW_localVariableDeclaration_in_forInit4962 = new BitSet(new long[]{0x0000000000000002L});
20365     public static final BitSet FOLLOW_expressionList_in_forInit4972 = new BitSet(new long[]{0x0000000000000002L});
20366     public static final BitSet FOLLOW_LPAREN_in_parExpression4991 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20367     public static final BitSet FOLLOW_expression_in_parExpression4993 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20368     public static final BitSet FOLLOW_RPAREN_in_parExpression4995 = new BitSet(new long[]{0x0000000000000002L});
20369     public static final BitSet FOLLOW_expression_in_expressionList5014 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20370     public static final BitSet FOLLOW_COMMA_in_expressionList5025 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20371     public static final BitSet FOLLOW_expression_in_expressionList5027 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20372     public static final BitSet FOLLOW_conditionalExpression_in_expression5058 = new BitSet(new long[]{0x0000000000000002L,0x0033FC0001000000L});
20373     public static final BitSet FOLLOW_assignmentOperator_in_expression5069 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20374     public static final BitSet FOLLOW_expression_in_expression5071 = new BitSet(new long[]{0x0000000000000002L});
20375     public static final BitSet FOLLOW_EQ_in_assignmentOperator5102 = new BitSet(new long[]{0x0000000000000002L});
20376     public static final BitSet FOLLOW_PLUSEQ_in_assignmentOperator5112 = new BitSet(new long[]{0x0000000000000002L});
20377     public static final BitSet FOLLOW_SUBEQ_in_assignmentOperator5122 = new BitSet(new long[]{0x0000000000000002L});
20378     public static final BitSet FOLLOW_STAREQ_in_assignmentOperator5132 = new BitSet(new long[]{0x0000000000000002L});
20379     public static final BitSet FOLLOW_SLASHEQ_in_assignmentOperator5142 = new BitSet(new long[]{0x0000000000000002L});
20380     public static final BitSet FOLLOW_AMPEQ_in_assignmentOperator5152 = new BitSet(new long[]{0x0000000000000002L});
20381     public static final BitSet FOLLOW_BAREQ_in_assignmentOperator5162 = new BitSet(new long[]{0x0000000000000002L});
20382     public static final BitSet FOLLOW_CARETEQ_in_assignmentOperator5172 = new BitSet(new long[]{0x0000000000000002L});
20383     public static final BitSet FOLLOW_PERCENTEQ_in_assignmentOperator5182 = new BitSet(new long[]{0x0000000000000002L});
20384     public static final BitSet FOLLOW_LT_in_assignmentOperator5193 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L});
20385     public static final BitSet FOLLOW_LT_in_assignmentOperator5195 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
20386     public static final BitSet FOLLOW_EQ_in_assignmentOperator5197 = new BitSet(new long[]{0x0000000000000002L});
20387     public static final BitSet FOLLOW_GT_in_assignmentOperator5208 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L});
20388     public static final BitSet FOLLOW_GT_in_assignmentOperator5210 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L});
20389     public static final BitSet FOLLOW_GT_in_assignmentOperator5212 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
20390     public static final BitSet FOLLOW_EQ_in_assignmentOperator5214 = new BitSet(new long[]{0x0000000000000002L});
20391     public static final BitSet FOLLOW_GT_in_assignmentOperator5225 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L});
20392     public static final BitSet FOLLOW_GT_in_assignmentOperator5227 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
20393     public static final BitSet FOLLOW_EQ_in_assignmentOperator5229 = new BitSet(new long[]{0x0000000000000002L});
20394     public static final BitSet FOLLOW_conditionalOrExpression_in_conditionalExpression5249 = new BitSet(new long[]{0x0000000000000002L,0x0000000008000000L});
20395     public static final BitSet FOLLOW_QUES_in_conditionalExpression5260 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20396     public static final BitSet FOLLOW_expression_in_conditionalExpression5262 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
20397     public static final BitSet FOLLOW_COLON_in_conditionalExpression5264 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20398     public static final BitSet FOLLOW_conditionalExpression_in_conditionalExpression5266 = new BitSet(new long[]{0x0000000000000002L});
20399     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression5296 = new BitSet(new long[]{0x0000000000000002L,0x0000000080000000L});
20400     public static final BitSet FOLLOW_BARBAR_in_conditionalOrExpression5307 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20401     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression5309 = new BitSet(new long[]{0x0000000000000002L,0x0000000080000000L});
20402     public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5339 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L});
20403     public static final BitSet FOLLOW_AMPAMP_in_conditionalAndExpression5350 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20404     public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5352 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L});
20405     public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5382 = new BitSet(new long[]{0x0000000000000002L,0x0000008000000000L});
20406     public static final BitSet FOLLOW_BAR_in_inclusiveOrExpression5393 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20407     public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5395 = new BitSet(new long[]{0x0000000000000002L,0x0000008000000000L});
20408     public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression5425 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L});
20409     public static final BitSet FOLLOW_CARET_in_exclusiveOrExpression5436 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20410     public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression5438 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L});
20411     public static final BitSet FOLLOW_equalityExpression_in_andExpression5468 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L});
20412     public static final BitSet FOLLOW_AMP_in_andExpression5479 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20413     public static final BitSet FOLLOW_equalityExpression_in_andExpression5481 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L});
20414     public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression5511 = new BitSet(new long[]{0x0000000000000002L,0x0008000020000000L});
20415     public static final BitSet FOLLOW_set_in_equalityExpression5535 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20416     public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression5585 = new BitSet(new long[]{0x0000000000000002L,0x0008000020000000L});
20417     public static final BitSet FOLLOW_relationalExpression_in_instanceOfExpression5615 = new BitSet(new long[]{0x0020000000000002L});
20418     public static final BitSet FOLLOW_INSTANCEOF_in_instanceOfExpression5626 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20419     public static final BitSet FOLLOW_type_in_instanceOfExpression5628 = new BitSet(new long[]{0x0000000000000002L});
20420     public static final BitSet FOLLOW_shiftExpression_in_relationalExpression5658 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L});
20421     public static final BitSet FOLLOW_relationalOp_in_relationalExpression5669 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20422     public static final BitSet FOLLOW_shiftExpression_in_relationalExpression5671 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L});
20423     public static final BitSet FOLLOW_LT_in_relationalOp5702 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
20424     public static final BitSet FOLLOW_EQ_in_relationalOp5704 = new BitSet(new long[]{0x0000000000000002L});
20425     public static final BitSet FOLLOW_GT_in_relationalOp5715 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L});
20426     public static final BitSet FOLLOW_EQ_in_relationalOp5717 = new BitSet(new long[]{0x0000000000000002L});
20427     public static final BitSet FOLLOW_LT_in_relationalOp5727 = new BitSet(new long[]{0x0000000000000002L});
20428     public static final BitSet FOLLOW_GT_in_relationalOp5737 = new BitSet(new long[]{0x0000000000000002L});
20429     public static final BitSet FOLLOW_additiveExpression_in_shiftExpression5756 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L});
20430     public static final BitSet FOLLOW_shiftOp_in_shiftExpression5767 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20431     public static final BitSet FOLLOW_additiveExpression_in_shiftExpression5769 = new BitSet(new long[]{0x0000000000000002L,0x0030000000000000L});
20432     public static final BitSet FOLLOW_LT_in_shiftOp5801 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L});
20433     public static final BitSet FOLLOW_LT_in_shiftOp5803 = new BitSet(new long[]{0x0000000000000002L});
20434     public static final BitSet FOLLOW_GT_in_shiftOp5814 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L});
20435     public static final BitSet FOLLOW_GT_in_shiftOp5816 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L});
20436     public static final BitSet FOLLOW_GT_in_shiftOp5818 = new BitSet(new long[]{0x0000000000000002L});
20437     public static final BitSet FOLLOW_GT_in_shiftOp5829 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L});
20438     public static final BitSet FOLLOW_GT_in_shiftOp5831 = new BitSet(new long[]{0x0000000000000002L});
20439     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression5851 = new BitSet(new long[]{0x0000000000000002L,0x0000000C00000000L});
20440     public static final BitSet FOLLOW_set_in_additiveExpression5875 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20441     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression5925 = new BitSet(new long[]{0x0000000000000002L,0x0000000C00000000L});
20442     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression5962 = new BitSet(new long[]{0x0000000000000002L,0x0000023000000000L});
20443     public static final BitSet FOLLOW_set_in_multiplicativeExpression5986 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20444     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression6054 = new BitSet(new long[]{0x0000000000000002L,0x0000023000000000L});
20445     public static final BitSet FOLLOW_PLUS_in_unaryExpression6086 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20446     public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6089 = new BitSet(new long[]{0x0000000000000002L});
20447     public static final BitSet FOLLOW_SUB_in_unaryExpression6099 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20448     public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6101 = new BitSet(new long[]{0x0000000000000002L});
20449     public static final BitSet FOLLOW_PLUSPLUS_in_unaryExpression6111 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20450     public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6113 = new BitSet(new long[]{0x0000000000000002L});
20451     public static final BitSet FOLLOW_SUBSUB_in_unaryExpression6123 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20452     public static final BitSet FOLLOW_unaryExpression_in_unaryExpression6125 = new BitSet(new long[]{0x0000000000000002L});
20453     public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression6135 = new BitSet(new long[]{0x0000000000000002L});
20454     public static final BitSet FOLLOW_TILDE_in_unaryExpressionNotPlusMinus6154 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20455     public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6156 = new BitSet(new long[]{0x0000000000000002L});
20456     public static final BitSet FOLLOW_BANG_in_unaryExpressionNotPlusMinus6166 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20457     public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6168 = new BitSet(new long[]{0x0000000000000002L});
20458     public static final BitSet FOLLOW_castExpression_in_unaryExpressionNotPlusMinus6178 = new BitSet(new long[]{0x0000000000000002L});
20459     public static final BitSet FOLLOW_primary_in_unaryExpressionNotPlusMinus6188 = new BitSet(new long[]{0x0000000000000002L,0x0000000300440000L});
20460     public static final BitSet FOLLOW_selector_in_unaryExpressionNotPlusMinus6199 = new BitSet(new long[]{0x0000000000000002L,0x0000000300440000L});
20461     public static final BitSet FOLLOW_set_in_unaryExpressionNotPlusMinus6220 = new BitSet(new long[]{0x0000000000000002L});
20462     public static final BitSet FOLLOW_LPAREN_in_castExpression6268 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20463     public static final BitSet FOLLOW_primitiveType_in_castExpression6270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20464     public static final BitSet FOLLOW_RPAREN_in_castExpression6272 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20465     public static final BitSet FOLLOW_unaryExpression_in_castExpression6274 = new BitSet(new long[]{0x0000000000000002L});
20466     public static final BitSet FOLLOW_LPAREN_in_castExpression6284 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20467     public static final BitSet FOLLOW_type_in_castExpression6286 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20468     public static final BitSet FOLLOW_RPAREN_in_castExpression6288 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20469     public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_castExpression6290 = new BitSet(new long[]{0x0000000000000002L});
20470     public static final BitSet FOLLOW_parExpression_in_primary6311 = new BitSet(new long[]{0x0000000000000002L});
20471     public static final BitSet FOLLOW_THIS_in_primary6321 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L});
20472     public static final BitSet FOLLOW_DOT_in_primary6332 = new BitSet(new long[]{0x0000000000000010L});
20473     public static final BitSet FOLLOW_IDENTIFIER_in_primary6334 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L});
20474     public static final BitSet FOLLOW_identifierSuffix_in_primary6356 = new BitSet(new long[]{0x0000000000000002L});
20475     public static final BitSet FOLLOW_IDENTIFIER_in_primary6377 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L});
20476     public static final BitSet FOLLOW_DOT_in_primary6388 = new BitSet(new long[]{0x0000000000000010L});
20477     public static final BitSet FOLLOW_IDENTIFIER_in_primary6390 = new BitSet(new long[]{0x0000000000000002L,0x0000000000444000L});
20478     public static final BitSet FOLLOW_identifierSuffix_in_primary6412 = new BitSet(new long[]{0x0000000000000002L});
20479     public static final BitSet FOLLOW_SUPER_in_primary6433 = new BitSet(new long[]{0x0000000000000000L,0x0000000000404000L});
20480     public static final BitSet FOLLOW_superSuffix_in_primary6443 = new BitSet(new long[]{0x0000000000000002L});
20481     public static final BitSet FOLLOW_literal_in_primary6453 = new BitSet(new long[]{0x0000000000000002L});
20482     public static final BitSet FOLLOW_creator_in_primary6463 = new BitSet(new long[]{0x0000000000000002L});
20483     public static final BitSet FOLLOW_primitiveType_in_primary6473 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L});
20484     public static final BitSet FOLLOW_LBRACKET_in_primary6484 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20485     public static final BitSet FOLLOW_RBRACKET_in_primary6486 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L});
20486     public static final BitSet FOLLOW_DOT_in_primary6507 = new BitSet(new long[]{0x0000001000000000L});
20487     public static final BitSet FOLLOW_CLASS_in_primary6509 = new BitSet(new long[]{0x0000000000000002L});
20488     public static final BitSet FOLLOW_VOID_in_primary6519 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
20489     public static final BitSet FOLLOW_DOT_in_primary6521 = new BitSet(new long[]{0x0000001000000000L});
20490     public static final BitSet FOLLOW_CLASS_in_primary6523 = new BitSet(new long[]{0x0000000000000002L});
20491     public static final BitSet FOLLOW_arguments_in_superSuffix6543 = new BitSet(new long[]{0x0000000000000002L});
20492     public static final BitSet FOLLOW_DOT_in_superSuffix6553 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L});
20493     public static final BitSet FOLLOW_typeArguments_in_superSuffix6556 = new BitSet(new long[]{0x0000000000000010L});
20494     public static final BitSet FOLLOW_IDENTIFIER_in_superSuffix6577 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
20495     public static final BitSet FOLLOW_arguments_in_superSuffix6588 = new BitSet(new long[]{0x0000000000000002L});
20496     public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix6620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20497     public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix6622 = new BitSet(new long[]{0x0000000000000000L,0x0000000000440000L});
20498     public static final BitSet FOLLOW_DOT_in_identifierSuffix6643 = new BitSet(new long[]{0x0000001000000000L});
20499     public static final BitSet FOLLOW_CLASS_in_identifierSuffix6645 = new BitSet(new long[]{0x0000000000000002L});
20500     public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix6656 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20501     public static final BitSet FOLLOW_expression_in_identifierSuffix6658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20502     public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix6660 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20503     public static final BitSet FOLLOW_arguments_in_identifierSuffix6681 = new BitSet(new long[]{0x0000000000000002L});
20504     public static final BitSet FOLLOW_DOT_in_identifierSuffix6691 = new BitSet(new long[]{0x0000001000000000L});
20505     public static final BitSet FOLLOW_CLASS_in_identifierSuffix6693 = new BitSet(new long[]{0x0000000000000002L});
20506     public static final BitSet FOLLOW_DOT_in_identifierSuffix6703 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L});
20507     public static final BitSet FOLLOW_nonWildcardTypeArguments_in_identifierSuffix6705 = new BitSet(new long[]{0x0000000000000010L});
20508     public static final BitSet FOLLOW_IDENTIFIER_in_identifierSuffix6707 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20509     public static final BitSet FOLLOW_arguments_in_identifierSuffix6709 = new BitSet(new long[]{0x0000000000000002L});
20510     public static final BitSet FOLLOW_DOT_in_identifierSuffix6719 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
20511     public static final BitSet FOLLOW_THIS_in_identifierSuffix6721 = new BitSet(new long[]{0x0000000000000002L});
20512     public static final BitSet FOLLOW_DOT_in_identifierSuffix6731 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
20513     public static final BitSet FOLLOW_SUPER_in_identifierSuffix6733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20514     public static final BitSet FOLLOW_arguments_in_identifierSuffix6735 = new BitSet(new long[]{0x0000000000000002L});
20515     public static final BitSet FOLLOW_innerCreator_in_identifierSuffix6745 = new BitSet(new long[]{0x0000000000000002L});
20516     public static final BitSet FOLLOW_DOT_in_selector6765 = new BitSet(new long[]{0x0000000000000010L});
20517     public static final BitSet FOLLOW_IDENTIFIER_in_selector6767 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
20518     public static final BitSet FOLLOW_arguments_in_selector6778 = new BitSet(new long[]{0x0000000000000002L});
20519     public static final BitSet FOLLOW_DOT_in_selector6799 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
20520     public static final BitSet FOLLOW_THIS_in_selector6801 = new BitSet(new long[]{0x0000000000000002L});
20521     public static final BitSet FOLLOW_DOT_in_selector6811 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
20522     public static final BitSet FOLLOW_SUPER_in_selector6813 = new BitSet(new long[]{0x0000000000000000L,0x0000000000404000L});
20523     public static final BitSet FOLLOW_superSuffix_in_selector6823 = new BitSet(new long[]{0x0000000000000002L});
20524     public static final BitSet FOLLOW_innerCreator_in_selector6833 = new BitSet(new long[]{0x0000000000000002L});
20525     public static final BitSet FOLLOW_LBRACKET_in_selector6843 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20526     public static final BitSet FOLLOW_expression_in_selector6845 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20527     public static final BitSet FOLLOW_RBRACKET_in_selector6847 = new BitSet(new long[]{0x0000000000000002L});
20528     public static final BitSet FOLLOW_NEW_in_creator6866 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L});
20529     public static final BitSet FOLLOW_nonWildcardTypeArguments_in_creator6868 = new BitSet(new long[]{0x0000000000000010L});
20530     public static final BitSet FOLLOW_classOrInterfaceType_in_creator6870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20531     public static final BitSet FOLLOW_classCreatorRest_in_creator6872 = new BitSet(new long[]{0x0000000000000002L});
20532     public static final BitSet FOLLOW_NEW_in_creator6882 = new BitSet(new long[]{0x0000000000000010L});
20533     public static final BitSet FOLLOW_classOrInterfaceType_in_creator6884 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20534     public static final BitSet FOLLOW_classCreatorRest_in_creator6886 = new BitSet(new long[]{0x0000000000000002L});
20535     public static final BitSet FOLLOW_arrayCreator_in_creator6896 = new BitSet(new long[]{0x0000000000000002L});
20536     public static final BitSet FOLLOW_NEW_in_arrayCreator6915 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20537     public static final BitSet FOLLOW_createdName_in_arrayCreator6917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
20538     public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6927 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20539     public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6929 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L});
20540     public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6940 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20541     public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6942 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L});
20542     public static final BitSet FOLLOW_arrayInitializer_in_arrayCreator6963 = new BitSet(new long[]{0x0000000000000002L});
20543     public static final BitSet FOLLOW_NEW_in_arrayCreator6974 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20544     public static final BitSet FOLLOW_createdName_in_arrayCreator6976 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
20545     public static final BitSet FOLLOW_LBRACKET_in_arrayCreator6986 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20546     public static final BitSet FOLLOW_expression_in_arrayCreator6988 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20547     public static final BitSet FOLLOW_RBRACKET_in_arrayCreator6998 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20548     public static final BitSet FOLLOW_LBRACKET_in_arrayCreator7012 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20549     public static final BitSet FOLLOW_expression_in_arrayCreator7014 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20550     public static final BitSet FOLLOW_RBRACKET_in_arrayCreator7028 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20551     public static final BitSet FOLLOW_LBRACKET_in_arrayCreator7050 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20552     public static final BitSet FOLLOW_RBRACKET_in_arrayCreator7052 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
20553     public static final BitSet FOLLOW_arrayInitializer_in_variableInitializer7082 = new BitSet(new long[]{0x0000000000000002L});
20554     public static final BitSet FOLLOW_expression_in_variableInitializer7092 = new BitSet(new long[]{0x0000000000000002L});
20555     public static final BitSet FOLLOW_LBRACE_in_arrayInitializer7111 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06234849L});
20556     public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer7126 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L});
20557     public static final BitSet FOLLOW_COMMA_in_arrayInitializer7145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06014849L});
20558     public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer7147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000220000L});
20559     public static final BitSet FOLLOW_COMMA_in_arrayInitializer7196 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
20560     public static final BitSet FOLLOW_RBRACE_in_arrayInitializer7208 = new BitSet(new long[]{0x0000000000000002L});
20561     public static final BitSet FOLLOW_classOrInterfaceType_in_createdName7241 = new BitSet(new long[]{0x0000000000000002L});
20562     public static final BitSet FOLLOW_primitiveType_in_createdName7251 = new BitSet(new long[]{0x0000000000000002L});
20563     public static final BitSet FOLLOW_DOT_in_innerCreator7270 = new BitSet(new long[]{0x0400000000000000L});
20564     public static final BitSet FOLLOW_NEW_in_innerCreator7272 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L});
20565     public static final BitSet FOLLOW_nonWildcardTypeArguments_in_innerCreator7283 = new BitSet(new long[]{0x0000000000000010L});
20566     public static final BitSet FOLLOW_IDENTIFIER_in_innerCreator7304 = new BitSet(new long[]{0x0000000000000000L,0x0020000000004000L});
20567     public static final BitSet FOLLOW_typeArguments_in_innerCreator7315 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20568     public static final BitSet FOLLOW_classCreatorRest_in_innerCreator7336 = new BitSet(new long[]{0x0000000000000002L});
20569     public static final BitSet FOLLOW_arguments_in_classCreatorRest7356 = new BitSet(new long[]{0x0008100000000002L,0x0020000000010000L});
20570     public static final BitSet FOLLOW_classBody_in_classCreatorRest7367 = new BitSet(new long[]{0x0000000000000002L});
20571     public static final BitSet FOLLOW_LT_in_nonWildcardTypeArguments7398 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20572     public static final BitSet FOLLOW_typeList_in_nonWildcardTypeArguments7400 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L});
20573     public static final BitSet FOLLOW_GT_in_nonWildcardTypeArguments7410 = new BitSet(new long[]{0x0000000000000002L});
20574     public static final BitSet FOLLOW_LPAREN_in_arguments7429 = new BitSet(new long[]{0x0540A20940003FF0L,0x0024000F0600C849L});
20575     public static final BitSet FOLLOW_expressionList_in_arguments7432 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20576     public static final BitSet FOLLOW_RPAREN_in_arguments7445 = new BitSet(new long[]{0x0000000000000002L});
20577     public static final BitSet FOLLOW_set_in_literal0 = new BitSet(new long[]{0x0000000000000002L});
20578     public static final BitSet FOLLOW_modifiers_in_classHeader7566 = new BitSet(new long[]{0x0000001000000000L});
20579     public static final BitSet FOLLOW_CLASS_in_classHeader7568 = new BitSet(new long[]{0x0000000000000010L});
20580     public static final BitSet FOLLOW_IDENTIFIER_in_classHeader7570 = new BitSet(new long[]{0x0000000000000002L});
20581     public static final BitSet FOLLOW_modifiers_in_enumHeader7589 = new BitSet(new long[]{0x0000080000000010L});
20582     public static final BitSet FOLLOW_set_in_enumHeader7591 = new BitSet(new long[]{0x0000000000000010L});
20583     public static final BitSet FOLLOW_IDENTIFIER_in_enumHeader7597 = new BitSet(new long[]{0x0000000000000002L});
20584     public static final BitSet FOLLOW_modifiers_in_interfaceHeader7616 = new BitSet(new long[]{0x0080000000000000L});
20585     public static final BitSet FOLLOW_INTERFACE_in_interfaceHeader7618 = new BitSet(new long[]{0x0000000000000010L});
20586     public static final BitSet FOLLOW_IDENTIFIER_in_interfaceHeader7620 = new BitSet(new long[]{0x0000000000000002L});
20587     public static final BitSet FOLLOW_modifiers_in_annotationHeader7639 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L});
20588     public static final BitSet FOLLOW_MONKEYS_AT_in_annotationHeader7641 = new BitSet(new long[]{0x0080000000000000L});
20589     public static final BitSet FOLLOW_INTERFACE_in_annotationHeader7643 = new BitSet(new long[]{0x0000000000000010L});
20590     public static final BitSet FOLLOW_IDENTIFIER_in_annotationHeader7645 = new BitSet(new long[]{0x0000000000000002L});
20591     public static final BitSet FOLLOW_modifiers_in_typeHeader7664 = new BitSet(new long[]{0x0080081000000000L,0x0004000000000000L});
20592     public static final BitSet FOLLOW_CLASS_in_typeHeader7667 = new BitSet(new long[]{0x0000000000000010L});
20593     public static final BitSet FOLLOW_ENUM_in_typeHeader7669 = new BitSet(new long[]{0x0000000000000010L});
20594     public static final BitSet FOLLOW_MONKEYS_AT_in_typeHeader7672 = new BitSet(new long[]{0x0080000000000000L});
20595     public static final BitSet FOLLOW_INTERFACE_in_typeHeader7676 = new BitSet(new long[]{0x0000000000000010L});
20596     public static final BitSet FOLLOW_IDENTIFIER_in_typeHeader7680 = new BitSet(new long[]{0x0000000000000002L});
20597     public static final BitSet FOLLOW_modifiers_in_methodHeader7699 = new BitSet(new long[]{0x0140820940000010L,0x0020000000000801L});
20598     public static final BitSet FOLLOW_typeParameters_in_methodHeader7701 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000801L});
20599     public static final BitSet FOLLOW_type_in_methodHeader7705 = new BitSet(new long[]{0x0000000000000010L});
20600     public static final BitSet FOLLOW_VOID_in_methodHeader7707 = new BitSet(new long[]{0x0000000000000010L});
20601     public static final BitSet FOLLOW_IDENTIFIER_in_methodHeader7711 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20602     public static final BitSet FOLLOW_LPAREN_in_methodHeader7713 = new BitSet(new long[]{0x0000000000000002L});
20603     public static final BitSet FOLLOW_modifiers_in_fieldHeader7732 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20604     public static final BitSet FOLLOW_type_in_fieldHeader7734 = new BitSet(new long[]{0x0000000000000010L});
20605     public static final BitSet FOLLOW_IDENTIFIER_in_fieldHeader7736 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L});
20606     public static final BitSet FOLLOW_LBRACKET_in_fieldHeader7739 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20607     public static final BitSet FOLLOW_RBRACKET_in_fieldHeader7740 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L});
20608     public static final BitSet FOLLOW_set_in_fieldHeader7744 = new BitSet(new long[]{0x0000000000000002L});
20609     public static final BitSet FOLLOW_variableModifiers_in_localVariableHeader7769 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20610     public static final BitSet FOLLOW_type_in_localVariableHeader7771 = new BitSet(new long[]{0x0000000000000010L});
20611     public static final BitSet FOLLOW_IDENTIFIER_in_localVariableHeader7773 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L});
20612     public static final BitSet FOLLOW_LBRACKET_in_localVariableHeader7776 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20613     public static final BitSet FOLLOW_RBRACKET_in_localVariableHeader7777 = new BitSet(new long[]{0x0000000000000000L,0x0000000001340000L});
20614     public static final BitSet FOLLOW_set_in_localVariableHeader7781 = new BitSet(new long[]{0x0000000000000002L});
20615     public static final BitSet FOLLOW_annotations_in_synpred2_Java64 = new BitSet(new long[]{0x0800000000000000L});
20616     public static final BitSet FOLLOW_packageDeclaration_in_synpred2_Java93 = new BitSet(new long[]{0x0000000000000002L});
20617     public static final BitSet FOLLOW_classDeclaration_in_synpred12_Java436 = new BitSet(new long[]{0x0000000000000002L});
20618     public static final BitSet FOLLOW_normalClassDeclaration_in_synpred27_Java659 = new BitSet(new long[]{0x0000000000000002L});
20619     public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred43_Java1306 = new BitSet(new long[]{0x0000000000000002L});
20620     public static final BitSet FOLLOW_fieldDeclaration_in_synpred52_Java1621 = new BitSet(new long[]{0x0000000000000002L});
20621     public static final BitSet FOLLOW_methodDeclaration_in_synpred53_Java1632 = new BitSet(new long[]{0x0000000000000002L});
20622     public static final BitSet FOLLOW_classDeclaration_in_synpred54_Java1643 = new BitSet(new long[]{0x0000000000000002L});
20623     public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred57_Java1778 = new BitSet(new long[]{0x0000000000000002L});
20624     public static final BitSet FOLLOW_modifiers_in_synpred59_Java1691 = new BitSet(new long[]{0x0000000000000010L,0x0020000000000000L});
20625     public static final BitSet FOLLOW_typeParameters_in_synpred59_Java1702 = new BitSet(new long[]{0x0000000000000010L});
20626     public static final BitSet FOLLOW_IDENTIFIER_in_synpred59_Java1723 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20627     public static final BitSet FOLLOW_formalParameters_in_synpred59_Java1733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010100L});
20628     public static final BitSet FOLLOW_THROWS_in_synpred59_Java1744 = new BitSet(new long[]{0x0000000000000010L});
20629     public static final BitSet FOLLOW_qualifiedNameList_in_synpred59_Java1746 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
20630     public static final BitSet FOLLOW_LBRACE_in_synpred59_Java1767 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL});
20631     public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred59_Java1778 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL});
20632     public static final BitSet FOLLOW_blockStatement_in_synpred59_Java1800 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06137EFFL});
20633     public static final BitSet FOLLOW_RBRACE_in_synpred59_Java1821 = new BitSet(new long[]{0x0000000000000002L});
20634     public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred68_Java2172 = new BitSet(new long[]{0x0000000000000002L});
20635     public static final BitSet FOLLOW_interfaceMethodDeclaration_in_synpred69_Java2182 = new BitSet(new long[]{0x0000000000000002L});
20636     public static final BitSet FOLLOW_interfaceDeclaration_in_synpred70_Java2192 = new BitSet(new long[]{0x0000000000000002L});
20637     public static final BitSet FOLLOW_classDeclaration_in_synpred71_Java2202 = new BitSet(new long[]{0x0000000000000002L});
20638     public static final BitSet FOLLOW_ellipsisParameterDecl_in_synpred96_Java2953 = new BitSet(new long[]{0x0000000000000002L});
20639     public static final BitSet FOLLOW_normalParameterDecl_in_synpred98_Java2963 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20640     public static final BitSet FOLLOW_COMMA_in_synpred98_Java2974 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L});
20641     public static final BitSet FOLLOW_normalParameterDecl_in_synpred98_Java2976 = new BitSet(new long[]{0x0000000000000002L,0x0000000000200000L});
20642     public static final BitSet FOLLOW_normalParameterDecl_in_synpred99_Java2998 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
20643     public static final BitSet FOLLOW_COMMA_in_synpred99_Java3008 = new BitSet(new long[]{0x0000000000000002L});
20644     public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred103_Java3139 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000048L});
20645     public static final BitSet FOLLOW_set_in_synpred103_Java3165 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20646     public static final BitSet FOLLOW_arguments_in_synpred103_Java3197 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20647     public static final BitSet FOLLOW_SEMI_in_synpred103_Java3199 = new BitSet(new long[]{0x0000000000000002L});
20648     public static final BitSet FOLLOW_annotationMethodDeclaration_in_synpred117_Java3781 = new BitSet(new long[]{0x0000000000000002L});
20649     public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred118_Java3791 = new BitSet(new long[]{0x0000000000000002L});
20650     public static final BitSet FOLLOW_normalClassDeclaration_in_synpred119_Java3801 = new BitSet(new long[]{0x0000000000000002L});
20651     public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred120_Java3811 = new BitSet(new long[]{0x0000000000000002L});
20652     public static final BitSet FOLLOW_enumDeclaration_in_synpred121_Java3821 = new BitSet(new long[]{0x0000000000000002L});
20653     public static final BitSet FOLLOW_annotationTypeDeclaration_in_synpred122_Java3831 = new BitSet(new long[]{0x0000000000000002L});
20654     public static final BitSet FOLLOW_localVariableDeclarationStatement_in_synpred125_Java3986 = new BitSet(new long[]{0x0000000000000002L});
20655     public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_synpred126_Java3996 = new BitSet(new long[]{0x0000000000000002L});
20656     public static final BitSet FOLLOW_ASSERT_in_synpred130_Java4122 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20657     public static final BitSet FOLLOW_expression_in_synpred130_Java4142 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L});
20658     public static final BitSet FOLLOW_COLON_in_synpred130_Java4145 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20659     public static final BitSet FOLLOW_expression_in_synpred130_Java4147 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20660     public static final BitSet FOLLOW_SEMI_in_synpred130_Java4151 = new BitSet(new long[]{0x0000000000000002L});
20661     public static final BitSet FOLLOW_ASSERT_in_synpred132_Java4161 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20662     public static final BitSet FOLLOW_expression_in_synpred132_Java4164 = new BitSet(new long[]{0x0000000000000000L,0x0000000010100000L});
20663     public static final BitSet FOLLOW_COLON_in_synpred132_Java4167 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20664     public static final BitSet FOLLOW_expression_in_synpred132_Java4169 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20665     public static final BitSet FOLLOW_SEMI_in_synpred132_Java4173 = new BitSet(new long[]{0x0000000000000002L});
20666     public static final BitSet FOLLOW_ELSE_in_synpred133_Java4190 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20667     public static final BitSet FOLLOW_statement_in_synpred133_Java4192 = new BitSet(new long[]{0x0000000000000002L});
20668     public static final BitSet FOLLOW_expression_in_synpred148_Java4404 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
20669     public static final BitSet FOLLOW_SEMI_in_synpred148_Java4407 = new BitSet(new long[]{0x0000000000000002L});
20670     public static final BitSet FOLLOW_IDENTIFIER_in_synpred149_Java4417 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
20671     public static final BitSet FOLLOW_COLON_in_synpred149_Java4419 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20672     public static final BitSet FOLLOW_statement_in_synpred149_Java4421 = new BitSet(new long[]{0x0000000000000002L});
20673     public static final BitSet FOLLOW_catches_in_synpred153_Java4573 = new BitSet(new long[]{0x0000400000000000L});
20674     public static final BitSet FOLLOW_FINALLY_in_synpred153_Java4575 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010002L});
20675     public static final BitSet FOLLOW_block_in_synpred153_Java4577 = new BitSet(new long[]{0x0000000000000002L});
20676     public static final BitSet FOLLOW_catches_in_synpred154_Java4591 = new BitSet(new long[]{0x0000000000000002L});
20677     public static final BitSet FOLLOW_FOR_in_synpred157_Java4775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20678     public static final BitSet FOLLOW_LPAREN_in_synpred157_Java4777 = new BitSet(new long[]{0x0140A20940000010L,0x0004000000000001L});
20679     public static final BitSet FOLLOW_variableModifiers_in_synpred157_Java4779 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20680     public static final BitSet FOLLOW_type_in_synpred157_Java4781 = new BitSet(new long[]{0x0000000000000010L});
20681     public static final BitSet FOLLOW_IDENTIFIER_in_synpred157_Java4783 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
20682     public static final BitSet FOLLOW_COLON_in_synpred157_Java4785 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20683     public static final BitSet FOLLOW_expression_in_synpred157_Java4795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20684     public static final BitSet FOLLOW_RPAREN_in_synpred157_Java4797 = new BitSet(new long[]{0xF7C5AB59F0003FF0L,0x0024000F06117EFFL});
20685     public static final BitSet FOLLOW_statement_in_synpred157_Java4799 = new BitSet(new long[]{0x0000000000000002L});
20686     public static final BitSet FOLLOW_localVariableDeclaration_in_synpred161_Java4962 = new BitSet(new long[]{0x0000000000000002L});
20687     public static final BitSet FOLLOW_castExpression_in_synpred202_Java6178 = new BitSet(new long[]{0x0000000000000002L});
20688     public static final BitSet FOLLOW_LPAREN_in_synpred206_Java6268 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20689     public static final BitSet FOLLOW_primitiveType_in_synpred206_Java6270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
20690     public static final BitSet FOLLOW_RPAREN_in_synpred206_Java6272 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20691     public static final BitSet FOLLOW_unaryExpression_in_synpred206_Java6274 = new BitSet(new long[]{0x0000000000000002L});
20692     public static final BitSet FOLLOW_DOT_in_synpred208_Java6332 = new BitSet(new long[]{0x0000000000000010L});
20693     public static final BitSet FOLLOW_IDENTIFIER_in_synpred208_Java6334 = new BitSet(new long[]{0x0000000000000002L});
20694     public static final BitSet FOLLOW_identifierSuffix_in_synpred209_Java6356 = new BitSet(new long[]{0x0000000000000002L});
20695     public static final BitSet FOLLOW_DOT_in_synpred211_Java6388 = new BitSet(new long[]{0x0000000000000010L});
20696     public static final BitSet FOLLOW_IDENTIFIER_in_synpred211_Java6390 = new BitSet(new long[]{0x0000000000000002L});
20697     public static final BitSet FOLLOW_identifierSuffix_in_synpred212_Java6412 = new BitSet(new long[]{0x0000000000000002L});
20698     public static final BitSet FOLLOW_LBRACKET_in_synpred224_Java6656 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20699     public static final BitSet FOLLOW_expression_in_synpred224_Java6658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20700     public static final BitSet FOLLOW_RBRACKET_in_synpred224_Java6660 = new BitSet(new long[]{0x0000000000000002L});
20701     public static final BitSet FOLLOW_NEW_in_synpred236_Java6866 = new BitSet(new long[]{0x0000000000000000L,0x0020000000000000L});
20702     public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred236_Java6868 = new BitSet(new long[]{0x0000000000000010L});
20703     public static final BitSet FOLLOW_classOrInterfaceType_in_synpred236_Java6870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20704     public static final BitSet FOLLOW_classCreatorRest_in_synpred236_Java6872 = new BitSet(new long[]{0x0000000000000002L});
20705     public static final BitSet FOLLOW_NEW_in_synpred237_Java6882 = new BitSet(new long[]{0x0000000000000010L});
20706     public static final BitSet FOLLOW_classOrInterfaceType_in_synpred237_Java6884 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
20707     public static final BitSet FOLLOW_classCreatorRest_in_synpred237_Java6886 = new BitSet(new long[]{0x0000000000000002L});
20708     public static final BitSet FOLLOW_NEW_in_synpred239_Java6915 = new BitSet(new long[]{0x0140820940000010L,0x0000000000000001L});
20709     public static final BitSet FOLLOW_createdName_in_synpred239_Java6917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
20710     public static final BitSet FOLLOW_LBRACKET_in_synpred239_Java6927 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20711     public static final BitSet FOLLOW_RBRACKET_in_synpred239_Java6929 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L});
20712     public static final BitSet FOLLOW_LBRACKET_in_synpred239_Java6940 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20713     public static final BitSet FOLLOW_RBRACKET_in_synpred239_Java6942 = new BitSet(new long[]{0x0000000000000000L,0x0000000000050000L});
20714     public static final BitSet FOLLOW_arrayInitializer_in_synpred239_Java6963 = new BitSet(new long[]{0x0000000000000002L});
20715     public static final BitSet FOLLOW_LBRACKET_in_synpred240_Java7012 = new BitSet(new long[]{0x0540820940003FF0L,0x0020000F06004849L});
20716     public static final BitSet FOLLOW_expression_in_synpred240_Java7014 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
20717     public static final BitSet FOLLOW_RBRACKET_in_synpred240_Java7028 = new BitSet(new long[]{0x0000000000000002L});
20718 
20719 }