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
17package com.google.doclava.parser;
18
19import org.antlr.runtime.BaseRecognizer;
20import org.antlr.runtime.BitSet;
21import org.antlr.runtime.DFA;
22import org.antlr.runtime.EarlyExitException;
23import org.antlr.runtime.IntStream;
24import org.antlr.runtime.MismatchedSetException;
25import org.antlr.runtime.NoViableAltException;
26import org.antlr.runtime.RecognitionException;
27import org.antlr.runtime.RecognizerSharedState;
28import org.antlr.runtime.TokenStream;
29import org.antlr.runtime.debug.DebugEventListener;
30import org.antlr.runtime.debug.DebugEventSocketProxy;
31import org.antlr.runtime.debug.DebugParser;
32
33import java.io.IOException;
34import 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 */
172public class JavaParser extends DebugParser {
173    public static final String[] tokenNames = new String[] {
174        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "IDENTIFIER", "INTLITERAL", "LONGLITERAL", "FLOATLITERAL", "DOUBLELITERAL", "CHARLITERAL", "STRINGLITERAL", "TRUE", "FALSE", "NULL", "IntegerNumber", "LongSuffix", "HexPrefix", "HexDigit", "Exponent", "NonIntegerNumber", "FloatSuffix", "DoubleSuffix", "EscapeSequence", "UNICODECHAR", "UNICODEPART", "WS", "COMMENT", "LINE_COMMENT", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "GOTO", "IF", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", "SEMI", "COMMA", "DOT", "ELLIPSIS", "EQ", "BANG", "TILDE", "QUES", "COLON", "EQEQ", "AMPAMP", "BARBAR", "PLUSPLUS", "SUBSUB", "PLUS", "SUB", "STAR", "SLASH", "AMP", "BAR", "CARET", "PERCENT", "PLUSEQ", "SUBEQ", "STAREQ", "SLASHEQ", "AMPEQ", "BAREQ", "CARETEQ", "PERCENTEQ", "MONKEYS_AT", "BANGEQ", "GT", "LT", "IdentifierStart", "IdentifierPart", "SurrogateIdentifer"
175    };
176    public static final int EOF=-1;
177    public static final int IDENTIFIER=4;
178    public static final int INTLITERAL=5;
179    public static final int LONGLITERAL=6;
180    public static final int FLOATLITERAL=7;
181    public static final int DOUBLELITERAL=8;
182    public static final int CHARLITERAL=9;
183    public static final int STRINGLITERAL=10;
184    public static final int TRUE=11;
185    public static final int FALSE=12;
186    public static final int NULL=13;
187    public static final int IntegerNumber=14;
188    public static final int LongSuffix=15;
189    public static final int HexPrefix=16;
190    public static final int HexDigit=17;
191    public static final int Exponent=18;
192    public static final int NonIntegerNumber=19;
193    public static final int FloatSuffix=20;
194    public static final int DoubleSuffix=21;
195    public static final int EscapeSequence=22;
196    public static final int UNICODECHAR=23;
197    public static final int UNICODEPART=24;
198    public static final int WS=25;
199    public static final int COMMENT=26;
200    public static final int LINE_COMMENT=27;
201    public static final int ABSTRACT=28;
202    public static final int ASSERT=29;
203    public static final int BOOLEAN=30;
204    public static final int BREAK=31;
205    public static final int BYTE=32;
206    public static final int CASE=33;
207    public static final int CATCH=34;
208    public static final int CHAR=35;
209    public static final int CLASS=36;
210    public static final int CONST=37;
211    public static final int CONTINUE=38;
212    public static final int DEFAULT=39;
213    public static final int DO=40;
214    public static final int DOUBLE=41;
215    public static final int ELSE=42;
216    public static final int ENUM=43;
217    public static final int EXTENDS=44;
218    public static final int FINAL=45;
219    public static final int FINALLY=46;
220    public static final int FLOAT=47;
221    public static final int FOR=48;
222    public static final int GOTO=49;
223    public static final int IF=50;
224    public static final int IMPLEMENTS=51;
225    public static final int IMPORT=52;
226    public static final int INSTANCEOF=53;
227    public static final int INT=54;
228    public static final int INTERFACE=55;
229    public static final int LONG=56;
230    public static final int NATIVE=57;
231    public static final int NEW=58;
232    public static final int PACKAGE=59;
233    public static final int PRIVATE=60;
234    public static final int PROTECTED=61;
235    public static final int PUBLIC=62;
236    public static final int RETURN=63;
237    public static final int SHORT=64;
238    public static final int STATIC=65;
239    public static final int STRICTFP=66;
240    public static final int SUPER=67;
241    public static final int SWITCH=68;
242    public static final int SYNCHRONIZED=69;
243    public static final int THIS=70;
244    public static final int THROW=71;
245    public static final int THROWS=72;
246    public static final int TRANSIENT=73;
247    public static final int TRY=74;
248    public static final int VOID=75;
249    public static final int VOLATILE=76;
250    public static final int WHILE=77;
251    public static final int LPAREN=78;
252    public static final int RPAREN=79;
253    public static final int LBRACE=80;
254    public static final int RBRACE=81;
255    public static final int LBRACKET=82;
256    public static final int RBRACKET=83;
257    public static final int SEMI=84;
258    public static final int COMMA=85;
259    public static final int DOT=86;
260    public static final int ELLIPSIS=87;
261    public static final int EQ=88;
262    public static final int BANG=89;
263    public static final int TILDE=90;
264    public static final int QUES=91;
265    public static final int COLON=92;
266    public static final int EQEQ=93;
267    public static final int AMPAMP=94;
268    public static final int BARBAR=95;
269    public static final int PLUSPLUS=96;
270    public static final int SUBSUB=97;
271    public static final int PLUS=98;
272    public static final int SUB=99;
273    public static final int STAR=100;
274    public static final int SLASH=101;
275    public static final int AMP=102;
276    public static final int BAR=103;
277    public static final int CARET=104;
278    public static final int PERCENT=105;
279    public static final int PLUSEQ=106;
280    public static final int SUBEQ=107;
281    public static final int STAREQ=108;
282    public static final int SLASHEQ=109;
283    public static final int AMPEQ=110;
284    public static final int BAREQ=111;
285    public static final int CARETEQ=112;
286    public static final int PERCENTEQ=113;
287    public static final int MONKEYS_AT=114;
288    public static final int BANGEQ=115;
289    public static final int GT=116;
290    public static final int LT=117;
291    public static final int IdentifierStart=118;
292    public static final int IdentifierPart=119;
293    public static final int SurrogateIdentifer=120;
294
295    // delegates
296    // delegators
297
298    public static final String[] ruleNames = new String[] {
299        "invalidRule", "typeList", "synpred114_Java", "synpred175_Java",
300        "synpred19_Java", "elementValuePairs", "identifierSuffix", "interfaceFieldDeclaration",
301        "synpred69_Java", "synpred263_Java", "synpred231_Java", "synpred267_Java",
302        "synpred111_Java", "block", "synpred261_Java", "elementValuePair",
303        "typeArgument", "synpred264_Java", "synpred95_Java", "synpred93_Java",
304        "synpred215_Java", "normalInterfaceDeclaration", "enumHeader", "synpred236_Java",
305        "createdName", "synpred271_Java", "synpred230_Java", "synpred30_Java",
306        "synpred212_Java", "synpred82_Java", "synpred128_Java", "synpred83_Java",
307        "synpred255_Java", "synpred190_Java", "arrayInitializer", "interfaceDeclaration",
308        "synpred92_Java", "localVariableHeader", "packageDeclaration", "formalParameter",
309        "catchClause", "synpred27_Java", "synpred270_Java", "synpred46_Java",
310        "synpred1_Java", "synpred4_Java", "synpred233_Java", "synpred120_Java",
311        "superSuffix", "literal", "classDeclaration", "synpred72_Java",
312        "synpred160_Java", "arguments", "synpred80_Java", "formalParameterDecls",
313        "synpred113_Java", "inclusiveOrExpression", "synpred71_Java", "selector",
314        "synpred194_Java", "synpred265_Java", "synpred173_Java", "synpred141_Java",
315        "synpred187_Java", "trystatement", "synpred133_Java", "interfaceHeader",
316        "synpred73_Java", "localVariableDeclarationStatement", "synpred102_Java",
317        "synpred90_Java", "equalityExpression", "synpred177_Java", "synpred149_Java",
318        "interfaceBodyDeclaration", "classCreatorRest", "synpred121_Java",
319        "synpred105_Java", "typeArguments", "synpred60_Java", "synpred195_Java",
320        "fieldDeclaration", "synpred269_Java", "synpred250_Java", "multiplicativeExpression",
321        "qualifiedNameList", "synpred86_Java", "synpred148_Java", "synpred142_Java",
322        "synpred65_Java", "synpred75_Java", "synpred235_Java", "synpred192_Java",
323        "synpred144_Java", "castExpression", "enumBody", "synpred70_Java",
324        "synpred33_Java", "synpred54_Java", "annotationTypeDeclaration",
325        "annotationHeader", "synpred107_Java", "synpred35_Java", "creator",
326        "nonWildcardTypeArguments", "variableInitializer", "enumConstants",
327        "synpred34_Java", "interfaceMethodDeclaration", "type", "synpred135_Java",
328        "synpred119_Java", "conditionalAndExpression", "synpred9_Java",
329        "synpred125_Java", "synpred40_Java", "synpred257_Java", "enumConstant",
330        "synpred143_Java", "synpred132_Java", "synpred146_Java", "synpred188_Java",
331        "ellipsisParameterDecl", "synpred245_Java", "synpred167_Java", "compilationUnit",
332        "synpred259_Java", "synpred64_Java", "synpred181_Java", "synpred23_Java",
333        "synpred12_Java", "synpred74_Java", "explicitConstructorInvocation",
334        "synpred266_Java", "synpred197_Java", "synpred147_Java", "synpred15_Java",
335        "synpred178_Java", "synpred174_Java", "exclusiveOrExpression", "forstatement",
336        "synpred7_Java", "synpred76_Java", "synpred224_Java", "parExpression",
337        "synpred241_Java", "synpred159_Java", "synpred260_Java", "synpred50_Java",
338        "synpred166_Java", "annotationMethodDeclaration", "synpred208_Java",
339        "synpred106_Java", "classOrInterfaceType", "qualifiedImportName",
340        "statement", "typeBound", "methodHeader", "synpred249_Java", "synpred55_Java",
341        "synpred131_Java", "classBodyDeclaration", "synpred189_Java", "synpred51_Java",
342        "synpred227_Java", "synpred220_Java", "synpred123_Java", "andExpression",
343        "synpred200_Java", "synpred165_Java", "relationalExpression", "annotationTypeBody",
344        "synpred210_Java", "synpred109_Java", "conditionalOrExpression",
345        "synpred161_Java", "classOrInterfaceDeclaration", "synpred180_Java",
346        "synpred154_Java", "elementValueArrayInitializer", "synpred14_Java",
347        "innerCreator", "synpred26_Java", "synpred52_Java", "synpred198_Java",
348        "synpred219_Java", "synpred126_Java", "synpred85_Java", "synpred88_Java",
349        "synpred68_Java", "synpred3_Java", "synpred203_Java", "annotations",
350        "elementValue", "synpred205_Java", "synpred6_Java", "synpred32_Java",
351        "synpred209_Java", "assignmentOperator", "synpred262_Java", "synpred139_Java",
352        "synpred29_Java", "synpred204_Java", "synpred118_Java", "synpred94_Java",
353        "synpred84_Java", "synpred63_Java", "conditionalExpression", "synpred56_Java",
354        "synpred162_Java", "primitiveType", "synpred240_Java", "synpred216_Java",
355        "synpred79_Java", "synpred99_Java", "additiveExpression", "synpred78_Java",
356        "modifiers", "synpred184_Java", "synpred168_Java", "synpred48_Java",
357        "switchBlockStatementGroups", "blockStatement", "synpred193_Java",
358        "classBody", "interfaceBody", "synpred67_Java", "synpred5_Java",
359        "synpred58_Java", "synpred254_Java", "localVariableDeclaration",
360        "annotationTypeElementDeclaration", "synpred251_Java", "arrayCreator",
361        "synpred226_Java", "synpred239_Java", "synpred191_Java", "synpred24_Java",
362        "normalClassDeclaration", "synpred98_Java", "synpred53_Java", "synpred145_Java",
363        "synpred22_Java", "synpred150_Java", "synpred238_Java", "synpred207_Java",
364        "variableModifiers", "typeParameters", "synpred38_Java", "synpred129_Java",
365        "enumBodyDeclarations", "synpred172_Java", "synpred16_Java", "synpred100_Java",
366        "fieldHeader", "synpred41_Java", "synpred248_Java", "synpred152_Java",
367        "synpred214_Java", "switchBlockStatementGroup", "synpred199_Java",
368        "switchLabel", "qualifiedName", "synpred137_Java", "synpred237_Java",
369        "synpred223_Java", "synpred156_Java", "synpred243_Java", "synpred182_Java",
370        "synpred138_Java", "synpred77_Java", "synpred127_Java", "synpred112_Java",
371        "unaryExpressionNotPlusMinus", "synpred42_Java", "synpred89_Java",
372        "formalParameters", "synpred225_Java", "synpred136_Java", "synpred186_Java",
373        "synpred122_Java", "synpred87_Java", "synpred244_Java", "synpred97_Java",
374        "synpred229_Java", "synpred170_Java", "shiftOp", "synpred134_Java",
375        "synpred253_Java", "synpred44_Java", "memberDecl", "synpred157_Java",
376        "synpred246_Java", "synpred49_Java", "synpred31_Java", "synpred256_Java",
377        "unaryExpression", "synpred13_Java", "synpred213_Java", "synpred155_Java",
378        "typeHeader", "synpred91_Java", "instanceOfExpression", "variableDeclarator",
379        "synpred140_Java", "synpred25_Java", "synpred117_Java", "synpred2_Java",
380        "synpred222_Java", "synpred10_Java", "synpred104_Java", "synpred115_Java",
381        "synpred221_Java", "synpred45_Java", "synpred211_Java", "typeParameter",
382        "synpred36_Java", "synpred103_Java", "synpred39_Java", "synpred201_Java",
383        "methodDeclaration", "synpred62_Java", "synpred110_Java", "classHeader",
384        "synpred101_Java", "synpred21_Java", "synpred196_Java", "synpred96_Java",
385        "synpred61_Java", "synpred228_Java", "synpred28_Java", "synpred218_Java",
386        "synpred179_Java", "normalParameterDecl", "enumDeclaration", "synpred17_Java",
387        "synpred18_Java", "synpred108_Java", "synpred43_Java", "synpred206_Java",
388        "synpred169_Java", "synpred130_Java", "synpred242_Java", "synpred252_Java",
389        "synpred151_Java", "forInit", "shiftExpression", "synpred81_Java",
390        "synpred247_Java", "synpred20_Java", "catches", "synpred202_Java",
391        "synpred47_Java", "synpred185_Java", "synpred158_Java", "synpred66_Java",
392        "synpred11_Java", "synpred8_Java", "synpred163_Java", "synpred217_Java",
393        "primary", "synpred153_Java", "synpred57_Java", "synpred258_Java",
394        "expressionList", "annotation", "expression", "synpred176_Java",
395        "synpred171_Java", "synpred164_Java", "importDeclaration", "synpred124_Java",
396        "synpred268_Java", "synpred234_Java", "relationalOp", "synpred59_Java",
397        "synpred37_Java", "synpred183_Java", "synpred232_Java", "synpred116_Java",
398        "typeDeclaration"
399    };
400    public static final boolean[] decisionCanBacktrack = new boolean[] {
401        false, // invalid decision
402        false, true, false, false, false, false, false, false, false, false,
403            false, true, false, false, true, false, false, false, false,
404            false, false, false, false, false, false, false, false, false,
405            false, false, true, false, false, false, false, false, false,
406            false, true, false, false, true, false, false, false, false,
407            false, false, true, false, false, false, true, false, false,
408            false, false, false, false, false, false, false, false, false,
409            false, false, false, false, false, false, true, true, false,
410            false, false, true, false, false, false, false, false, false,
411            false, false, false, false, true, false, false, true, false,
412            false, false, true, false, false, false, true, false, false,
413            false, true, false, false, false, false, false, true, true,
414            false, false, false, false, false, false, false, false, false,
415            false, false, false, false, false, false, false, false, false,
416            false, false, true, true, true, true, true, true, false, false,
417            false, false, false, false, true, false, false, false, true,
418            false, true, false, true, false, false, false, false, false,
419            false, false, false, false, false, false, false, false, false,
420            false, false, false, false, false, false, true, false, false,
421            false, false, false, false, false, false, false, false, false,
422            false, false, false, false, false, false, false, false, false,
423            false, false, false
424    };
425
426
427        public int ruleLevel = 0;
428        public int getRuleLevel() { return ruleLevel; }
429        public void incRuleLevel() { ruleLevel++; }
430        public void decRuleLevel() { ruleLevel--; }
431        public JavaParser(TokenStream input) {
432            this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
433        }
434        public JavaParser(TokenStream input, int port, RecognizerSharedState state) {
435            super(input, state);
436            this.state.ruleMemo = new HashMap[381+1];
437
438            DebugEventSocketProxy proxy =
439                new DebugEventSocketProxy(this, port, null);
440            setDebugListener(proxy);
441            try {
442                proxy.handshake();
443            }
444            catch (IOException ioe) {
445                reportError(ioe);
446            }
447        }
448    public JavaParser(TokenStream input, DebugEventListener dbg) {
449        super(input, dbg, new RecognizerSharedState());
450        this.state.ruleMemo = new HashMap[381+1];
451
452    }
453    protected boolean evalPredicate(boolean result, String predicate) {
454        dbg.semanticPredicate(result, predicate);
455        return result;
456    }
457
458
459    public String[] getTokenNames() { return JavaParser.tokenNames; }
460    public String getGrammarFileName() { return "src/com/google/doclava/parser/Java.g"; }
461
462
463
464    // $ANTLR start "compilationUnit"
465    // src/com/google/doclava/parser/Java.g:293:1: compilationUnit : ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ;
466    public final void compilationUnit() throws RecognitionException {
467        int compilationUnit_StartIndex = input.index();
468        try { dbg.enterRule(getGrammarFileName(), "compilationUnit");
469        if ( getRuleLevel()==0 ) {dbg.commence();}
470        incRuleLevel();
471        dbg.location(293, 1);
472
473        try {
474            if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return ; }
475            // src/com/google/doclava/parser/Java.g:298:5: ( ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* )
476            dbg.enterAlt(1);
477
478            // src/com/google/doclava/parser/Java.g:298:9: ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )*
479            {
480            dbg.location(298,9);
481            // src/com/google/doclava/parser/Java.g:298:9: ( ( annotations )? packageDeclaration )?
482            int alt2=2;
483            try { dbg.enterSubRule(2);
484            try { dbg.enterDecision(2, decisionCanBacktrack[2]);
485
486            try {
487                isCyclicDecision = true;
488                alt2 = dfa2.predict(input);
489            }
490            catch (NoViableAltException nvae) {
491                dbg.recognitionException(nvae);
492                throw nvae;
493            }
494            } finally {dbg.exitDecision(2);}
495
496            switch (alt2) {
497                case 1 :
498                    dbg.enterAlt(1);
499
500                    // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? packageDeclaration
501                    {
502                    dbg.location(298,13);
503                    // src/com/google/doclava/parser/Java.g:298:13: ( annotations )?
504                    int alt1=2;
505                    try { dbg.enterSubRule(1);
506                    try { dbg.enterDecision(1, decisionCanBacktrack[1]);
507
508                    int LA1_0 = input.LA(1);
509
510                    if ( (LA1_0==MONKEYS_AT) ) {
511                        alt1=1;
512                    }
513                    } finally {dbg.exitDecision(1);}
514
515                    switch (alt1) {
516                        case 1 :
517                            dbg.enterAlt(1);
518
519                            // src/com/google/doclava/parser/Java.g:298:14: annotations
520                            {
521                            dbg.location(298,14);
522                            pushFollow(FOLLOW_annotations_in_compilationUnit64);
523                            annotations();
524
525                            state._fsp--;
526                            if (state.failed) return ;
527
528                            }
529                            break;
530
531                    }
532                    } finally {dbg.exitSubRule(1);}
533
534                    dbg.location(300,13);
535                    pushFollow(FOLLOW_packageDeclaration_in_compilationUnit93);
536                    packageDeclaration();
537
538                    state._fsp--;
539                    if (state.failed) return ;
540
541                    }
542                    break;
543
544            }
545            } finally {dbg.exitSubRule(2);}
546
547            dbg.location(302,9);
548            // src/com/google/doclava/parser/Java.g:302:9: ( importDeclaration )*
549            try { dbg.enterSubRule(3);
550
551            loop3:
552            do {
553                int alt3=2;
554                try { dbg.enterDecision(3, decisionCanBacktrack[3]);
555
556                int LA3_0 = input.LA(1);
557
558                if ( (LA3_0==IMPORT) ) {
559                    alt3=1;
560                }
561
562
563                } finally {dbg.exitDecision(3);}
564
565                switch (alt3) {
566		case 1 :
567		    dbg.enterAlt(1);
568
569		    // src/com/google/doclava/parser/Java.g:302:10: importDeclaration
570		    {
571		    dbg.location(302,10);
572		    pushFollow(FOLLOW_importDeclaration_in_compilationUnit115);
573		    importDeclaration();
574
575		    state._fsp--;
576		    if (state.failed) return ;
577
578		    }
579		    break;
580
581		default :
582		    break loop3;
583                }
584            } while (true);
585            } finally {dbg.exitSubRule(3);}
586
587            dbg.location(304,9);
588            // src/com/google/doclava/parser/Java.g:304:9: ( typeDeclaration )*
589            try { dbg.enterSubRule(4);
590
591            loop4:
592            do {
593                int alt4=2;
594                try { dbg.enterDecision(4, decisionCanBacktrack[4]);
595
596                int LA4_0 = input.LA(1);
597
598                if ( (LA4_0==IDENTIFIER||LA4_0==ABSTRACT||LA4_0==BOOLEAN||LA4_0==BYTE||(LA4_0>=CHAR && LA4_0<=CLASS)||LA4_0==DOUBLE||LA4_0==ENUM||LA4_0==FINAL||LA4_0==FLOAT||(LA4_0>=INT && LA4_0<=NATIVE)||(LA4_0>=PRIVATE && LA4_0<=PUBLIC)||(LA4_0>=SHORT && LA4_0<=STRICTFP)||LA4_0==SYNCHRONIZED||LA4_0==TRANSIENT||(LA4_0>=VOID && LA4_0<=VOLATILE)||LA4_0==SEMI||LA4_0==MONKEYS_AT||LA4_0==LT) ) {
599                    alt4=1;
600                }
601
602
603                } finally {dbg.exitDecision(4);}
604
605                switch (alt4) {
606		case 1 :
607		    dbg.enterAlt(1);
608
609		    // src/com/google/doclava/parser/Java.g:304:10: typeDeclaration
610		    {
611		    dbg.location(304,10);
612		    pushFollow(FOLLOW_typeDeclaration_in_compilationUnit137);
613		    typeDeclaration();
614
615		    state._fsp--;
616		    if (state.failed) return ;
617
618		    }
619		    break;
620
621		default :
622		    break loop4;
623                }
624            } while (true);
625            } finally {dbg.exitSubRule(4);}
626
627
628            }
629
630        }
631        catch (RecognitionException re) {
632            reportError(re);
633            recover(input,re);
634        }
635        finally {
636            if ( state.backtracking>0 ) { memoize(input, 1, compilationUnit_StartIndex); }
637        }
638        dbg.location(306, 5);
639
640        }
641        finally {
642            dbg.exitRule(getGrammarFileName(), "compilationUnit");
643            decRuleLevel();
644            if ( getRuleLevel()==0 ) {dbg.terminate();}
645        }
646
647        return ;
648    }
649    // $ANTLR end "compilationUnit"
650
651
652    // $ANTLR start "packageDeclaration"
653    // src/com/google/doclava/parser/Java.g:308:1: packageDeclaration : 'package' qualifiedName ';' ;
654    public final void packageDeclaration() throws RecognitionException {
655        int packageDeclaration_StartIndex = input.index();
656        try { dbg.enterRule(getGrammarFileName(), "packageDeclaration");
657        if ( getRuleLevel()==0 ) {dbg.commence();}
658        incRuleLevel();
659        dbg.location(308, 1);
660
661        try {
662            if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return ; }
663            // src/com/google/doclava/parser/Java.g:309:5: ( 'package' qualifiedName ';' )
664            dbg.enterAlt(1);
665
666            // src/com/google/doclava/parser/Java.g:309:9: 'package' qualifiedName ';'
667            {
668            dbg.location(309,9);
669            match(input,PACKAGE,FOLLOW_PACKAGE_in_packageDeclaration167); if (state.failed) return ;
670            dbg.location(309,19);
671            pushFollow(FOLLOW_qualifiedName_in_packageDeclaration169);
672            qualifiedName();
673
674            state._fsp--;
675            if (state.failed) return ;
676            dbg.location(310,9);
677            match(input,SEMI,FOLLOW_SEMI_in_packageDeclaration179); if (state.failed) return ;
678
679            }
680
681        }
682        catch (RecognitionException re) {
683            reportError(re);
684            recover(input,re);
685        }
686        finally {
687            if ( state.backtracking>0 ) { memoize(input, 2, packageDeclaration_StartIndex); }
688        }
689        dbg.location(311, 5);
690
691        }
692        finally {
693            dbg.exitRule(getGrammarFileName(), "packageDeclaration");
694            decRuleLevel();
695            if ( getRuleLevel()==0 ) {dbg.terminate();}
696        }
697
698        return ;
699    }
700    // $ANTLR end "packageDeclaration"
701
702
703    // $ANTLR start "importDeclaration"
704    // src/com/google/doclava/parser/Java.g:313:1: importDeclaration : ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' );
705    public final void importDeclaration() throws RecognitionException {
706        int importDeclaration_StartIndex = input.index();
707        try { dbg.enterRule(getGrammarFileName(), "importDeclaration");
708        if ( getRuleLevel()==0 ) {dbg.commence();}
709        incRuleLevel();
710        dbg.location(313, 1);
711
712        try {
713            if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return ; }
714            // src/com/google/doclava/parser/Java.g:314:5: ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' )
715            int alt9=2;
716            try { dbg.enterDecision(9, decisionCanBacktrack[9]);
717
718            int LA9_0 = input.LA(1);
719
720            if ( (LA9_0==IMPORT) ) {
721                int LA9_1 = input.LA(2);
722
723                if ( (LA9_1==STATIC) ) {
724                    int LA9_2 = input.LA(3);
725
726                    if ( (LA9_2==IDENTIFIER) ) {
727                        int LA9_3 = input.LA(4);
728
729                        if ( (LA9_3==DOT) ) {
730                            int LA9_4 = input.LA(5);
731
732                            if ( (LA9_4==STAR) ) {
733                                alt9=1;
734                            }
735                            else if ( (LA9_4==IDENTIFIER) ) {
736                                alt9=2;
737                            }
738                            else {
739                                if (state.backtracking>0) {state.failed=true; return ;}
740                                NoViableAltException nvae =
741                                    new NoViableAltException("", 9, 4, input);
742
743                                dbg.recognitionException(nvae);
744                                throw nvae;
745                            }
746                        }
747                        else {
748                            if (state.backtracking>0) {state.failed=true; return ;}
749                            NoViableAltException nvae =
750                                new NoViableAltException("", 9, 3, input);
751
752                            dbg.recognitionException(nvae);
753                            throw nvae;
754                        }
755                    }
756                    else {
757                        if (state.backtracking>0) {state.failed=true; return ;}
758                        NoViableAltException nvae =
759                            new NoViableAltException("", 9, 2, input);
760
761                        dbg.recognitionException(nvae);
762                        throw nvae;
763                    }
764                }
765                else if ( (LA9_1==IDENTIFIER) ) {
766                    int LA9_3 = input.LA(3);
767
768                    if ( (LA9_3==DOT) ) {
769                        int LA9_4 = input.LA(4);
770
771                        if ( (LA9_4==STAR) ) {
772                            alt9=1;
773                        }
774                        else if ( (LA9_4==IDENTIFIER) ) {
775                            alt9=2;
776                        }
777                        else {
778                            if (state.backtracking>0) {state.failed=true; return ;}
779                            NoViableAltException nvae =
780                                new NoViableAltException("", 9, 4, input);
781
782                            dbg.recognitionException(nvae);
783                            throw nvae;
784                        }
785                    }
786                    else {
787                        if (state.backtracking>0) {state.failed=true; return ;}
788                        NoViableAltException nvae =
789                            new NoViableAltException("", 9, 3, input);
790
791                        dbg.recognitionException(nvae);
792                        throw nvae;
793                    }
794                }
795                else {
796                    if (state.backtracking>0) {state.failed=true; return ;}
797                    NoViableAltException nvae =
798                        new NoViableAltException("", 9, 1, input);
799
800                    dbg.recognitionException(nvae);
801                    throw nvae;
802                }
803            }
804            else {
805                if (state.backtracking>0) {state.failed=true; return ;}
806                NoViableAltException nvae =
807                    new NoViableAltException("", 9, 0, input);
808
809                dbg.recognitionException(nvae);
810                throw nvae;
811            }
812            } finally {dbg.exitDecision(9);}
813
814            switch (alt9) {
815                case 1 :
816                    dbg.enterAlt(1);
817
818                    // src/com/google/doclava/parser/Java.g:314:9: 'import' ( 'static' )? IDENTIFIER '.' '*' ';'
819                    {
820                    dbg.location(314,9);
821                    match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration198); if (state.failed) return ;
822                    dbg.location(315,9);
823                    // src/com/google/doclava/parser/Java.g:315:9: ( 'static' )?
824                    int alt5=2;
825                    try { dbg.enterSubRule(5);
826                    try { dbg.enterDecision(5, decisionCanBacktrack[5]);
827
828                    int LA5_0 = input.LA(1);
829
830                    if ( (LA5_0==STATIC) ) {
831                        alt5=1;
832                    }
833                    } finally {dbg.exitDecision(5);}
834
835                    switch (alt5) {
836                        case 1 :
837                            dbg.enterAlt(1);
838
839                            // src/com/google/doclava/parser/Java.g:315:10: 'static'
840                            {
841                            dbg.location(315,10);
842                            match(input,STATIC,FOLLOW_STATIC_in_importDeclaration209); if (state.failed) return ;
843
844                            }
845                            break;
846
847                    }
848                    } finally {dbg.exitSubRule(5);}
849
850                    dbg.location(317,9);
851                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration230); if (state.failed) return ;
852                    dbg.location(317,20);
853                    match(input,DOT,FOLLOW_DOT_in_importDeclaration232); if (state.failed) return ;
854                    dbg.location(317,24);
855                    match(input,STAR,FOLLOW_STAR_in_importDeclaration234); if (state.failed) return ;
856                    dbg.location(318,9);
857                    match(input,SEMI,FOLLOW_SEMI_in_importDeclaration244); if (state.failed) return ;
858
859                    }
860                    break;
861                case 2 :
862                    dbg.enterAlt(2);
863
864                    // src/com/google/doclava/parser/Java.g:319:9: 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';'
865                    {
866                    dbg.location(319,9);
867                    match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration254); if (state.failed) return ;
868                    dbg.location(320,9);
869                    // src/com/google/doclava/parser/Java.g:320:9: ( 'static' )?
870                    int alt6=2;
871                    try { dbg.enterSubRule(6);
872                    try { dbg.enterDecision(6, decisionCanBacktrack[6]);
873
874                    int LA6_0 = input.LA(1);
875
876                    if ( (LA6_0==STATIC) ) {
877                        alt6=1;
878                    }
879                    } finally {dbg.exitDecision(6);}
880
881                    switch (alt6) {
882                        case 1 :
883                            dbg.enterAlt(1);
884
885                            // src/com/google/doclava/parser/Java.g:320:10: 'static'
886                            {
887                            dbg.location(320,10);
888                            match(input,STATIC,FOLLOW_STATIC_in_importDeclaration265); if (state.failed) return ;
889
890                            }
891                            break;
892
893                    }
894                    } finally {dbg.exitSubRule(6);}
895
896                    dbg.location(322,9);
897                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration286); if (state.failed) return ;
898                    dbg.location(323,9);
899                    // src/com/google/doclava/parser/Java.g:323:9: ( '.' IDENTIFIER )+
900                    int cnt7=0;
901                    try { dbg.enterSubRule(7);
902
903                    loop7:
904                    do {
905                        int alt7=2;
906                        try { dbg.enterDecision(7, decisionCanBacktrack[7]);
907
908                        int LA7_0 = input.LA(1);
909
910                        if ( (LA7_0==DOT) ) {
911                            int LA7_1 = input.LA(2);
912
913                            if ( (LA7_1==IDENTIFIER) ) {
914                                alt7=1;
915                            }
916
917
918                        }
919
920
921                        } finally {dbg.exitDecision(7);}
922
923                        switch (alt7) {
924			case 1 :
925			    dbg.enterAlt(1);
926
927			    // src/com/google/doclava/parser/Java.g:323:10: '.' IDENTIFIER
928			    {
929			    dbg.location(323,10);
930			    match(input,DOT,FOLLOW_DOT_in_importDeclaration297); if (state.failed) return ;
931			    dbg.location(323,14);
932			    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration299); if (state.failed) return ;
933
934			    }
935			    break;
936
937			default :
938			    if ( cnt7 >= 1 ) break loop7;
939			    if (state.backtracking>0) {state.failed=true; return ;}
940                                EarlyExitException eee =
941                                    new EarlyExitException(7, input);
942                                dbg.recognitionException(eee);
943
944                                throw eee;
945                        }
946                        cnt7++;
947                    } while (true);
948                    } finally {dbg.exitSubRule(7);}
949
950                    dbg.location(325,9);
951                    // src/com/google/doclava/parser/Java.g:325:9: ( '.' '*' )?
952                    int alt8=2;
953                    try { dbg.enterSubRule(8);
954                    try { dbg.enterDecision(8, decisionCanBacktrack[8]);
955
956                    int LA8_0 = input.LA(1);
957
958                    if ( (LA8_0==DOT) ) {
959                        alt8=1;
960                    }
961                    } finally {dbg.exitDecision(8);}
962
963                    switch (alt8) {
964                        case 1 :
965                            dbg.enterAlt(1);
966
967                            // src/com/google/doclava/parser/Java.g:325:10: '.' '*'
968                            {
969                            dbg.location(325,10);
970                            match(input,DOT,FOLLOW_DOT_in_importDeclaration321); if (state.failed) return ;
971                            dbg.location(325,14);
972                            match(input,STAR,FOLLOW_STAR_in_importDeclaration323); if (state.failed) return ;
973
974                            }
975                            break;
976
977                    }
978                    } finally {dbg.exitSubRule(8);}
979
980                    dbg.location(327,9);
981                    match(input,SEMI,FOLLOW_SEMI_in_importDeclaration344); if (state.failed) return ;
982
983                    }
984                    break;
985
986            }
987        }
988        catch (RecognitionException re) {
989            reportError(re);
990            recover(input,re);
991        }
992        finally {
993            if ( state.backtracking>0 ) { memoize(input, 3, importDeclaration_StartIndex); }
994        }
995        dbg.location(328, 5);
996
997        }
998        finally {
999            dbg.exitRule(getGrammarFileName(), "importDeclaration");
1000            decRuleLevel();
1001            if ( getRuleLevel()==0 ) {dbg.terminate();}
1002        }
1003
1004        return ;
1005    }
1006    // $ANTLR end "importDeclaration"
1007
1008
1009    // $ANTLR start "qualifiedImportName"
1010    // src/com/google/doclava/parser/Java.g:330:1: qualifiedImportName : IDENTIFIER ( '.' IDENTIFIER )* ;
1011    public final void qualifiedImportName() throws RecognitionException {
1012        int qualifiedImportName_StartIndex = input.index();
1013        try { dbg.enterRule(getGrammarFileName(), "qualifiedImportName");
1014        if ( getRuleLevel()==0 ) {dbg.commence();}
1015        incRuleLevel();
1016        dbg.location(330, 1);
1017
1018        try {
1019            if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return ; }
1020            // src/com/google/doclava/parser/Java.g:331:5: ( IDENTIFIER ( '.' IDENTIFIER )* )
1021            dbg.enterAlt(1);
1022
1023            // src/com/google/doclava/parser/Java.g:331:9: IDENTIFIER ( '.' IDENTIFIER )*
1024            {
1025            dbg.location(331,9);
1026            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName363); if (state.failed) return ;
1027            dbg.location(332,9);
1028            // src/com/google/doclava/parser/Java.g:332:9: ( '.' IDENTIFIER )*
1029            try { dbg.enterSubRule(10);
1030
1031            loop10:
1032            do {
1033                int alt10=2;
1034                try { dbg.enterDecision(10, decisionCanBacktrack[10]);
1035
1036                int LA10_0 = input.LA(1);
1037
1038                if ( (LA10_0==DOT) ) {
1039                    alt10=1;
1040                }
1041
1042
1043                } finally {dbg.exitDecision(10);}
1044
1045                switch (alt10) {
1046		case 1 :
1047		    dbg.enterAlt(1);
1048
1049		    // src/com/google/doclava/parser/Java.g:332:10: '.' IDENTIFIER
1050		    {
1051		    dbg.location(332,10);
1052		    match(input,DOT,FOLLOW_DOT_in_qualifiedImportName374); if (state.failed) return ;
1053		    dbg.location(332,14);
1054		    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName376); if (state.failed) return ;
1055
1056		    }
1057		    break;
1058
1059		default :
1060		    break loop10;
1061                }
1062            } while (true);
1063            } finally {dbg.exitSubRule(10);}
1064
1065
1066            }
1067
1068        }
1069        catch (RecognitionException re) {
1070            reportError(re);
1071            recover(input,re);
1072        }
1073        finally {
1074            if ( state.backtracking>0 ) { memoize(input, 4, qualifiedImportName_StartIndex); }
1075        }
1076        dbg.location(334, 5);
1077
1078        }
1079        finally {
1080            dbg.exitRule(getGrammarFileName(), "qualifiedImportName");
1081            decRuleLevel();
1082            if ( getRuleLevel()==0 ) {dbg.terminate();}
1083        }
1084
1085        return ;
1086    }
1087    // $ANTLR end "qualifiedImportName"
1088
1089
1090    // $ANTLR start "typeDeclaration"
1091    // src/com/google/doclava/parser/Java.g:336:1: typeDeclaration : ( classOrInterfaceDeclaration | ';' );
1092    public final void typeDeclaration() throws RecognitionException {
1093        int typeDeclaration_StartIndex = input.index();
1094        try { dbg.enterRule(getGrammarFileName(), "typeDeclaration");
1095        if ( getRuleLevel()==0 ) {dbg.commence();}
1096        incRuleLevel();
1097        dbg.location(336, 1);
1098
1099        try {
1100            if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return ; }
1101            // src/com/google/doclava/parser/Java.g:337:5: ( classOrInterfaceDeclaration | ';' )
1102            int alt11=2;
1103            try { dbg.enterDecision(11, decisionCanBacktrack[11]);
1104
1105            int LA11_0 = input.LA(1);
1106
1107            if ( (LA11_0==IDENTIFIER||LA11_0==ABSTRACT||LA11_0==BOOLEAN||LA11_0==BYTE||(LA11_0>=CHAR && LA11_0<=CLASS)||LA11_0==DOUBLE||LA11_0==ENUM||LA11_0==FINAL||LA11_0==FLOAT||(LA11_0>=INT && LA11_0<=NATIVE)||(LA11_0>=PRIVATE && LA11_0<=PUBLIC)||(LA11_0>=SHORT && LA11_0<=STRICTFP)||LA11_0==SYNCHRONIZED||LA11_0==TRANSIENT||(LA11_0>=VOID && LA11_0<=VOLATILE)||LA11_0==MONKEYS_AT||LA11_0==LT) ) {
1108                alt11=1;
1109            }
1110            else if ( (LA11_0==SEMI) ) {
1111                alt11=2;
1112            }
1113            else {
1114                if (state.backtracking>0) {state.failed=true; return ;}
1115                NoViableAltException nvae =
1116                    new NoViableAltException("", 11, 0, input);
1117
1118                dbg.recognitionException(nvae);
1119                throw nvae;
1120            }
1121            } finally {dbg.exitDecision(11);}
1122
1123            switch (alt11) {
1124                case 1 :
1125                    dbg.enterAlt(1);
1126
1127                    // src/com/google/doclava/parser/Java.g:337:9: classOrInterfaceDeclaration
1128                    {
1129                    dbg.location(337,9);
1130                    pushFollow(FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration406);
1131                    classOrInterfaceDeclaration();
1132
1133                    state._fsp--;
1134                    if (state.failed) return ;
1135
1136                    }
1137                    break;
1138                case 2 :
1139                    dbg.enterAlt(2);
1140
1141                    // src/com/google/doclava/parser/Java.g:338:9: ';'
1142                    {
1143                    dbg.location(338,9);
1144                    match(input,SEMI,FOLLOW_SEMI_in_typeDeclaration416); if (state.failed) return ;
1145
1146                    }
1147                    break;
1148
1149            }
1150        }
1151        catch (RecognitionException re) {
1152            reportError(re);
1153            recover(input,re);
1154        }
1155        finally {
1156            if ( state.backtracking>0 ) { memoize(input, 5, typeDeclaration_StartIndex); }
1157        }
1158        dbg.location(339, 5);
1159
1160        }
1161        finally {
1162            dbg.exitRule(getGrammarFileName(), "typeDeclaration");
1163            decRuleLevel();
1164            if ( getRuleLevel()==0 ) {dbg.terminate();}
1165        }
1166
1167        return ;
1168    }
1169    // $ANTLR end "typeDeclaration"
1170
1171
1172    // $ANTLR start "classOrInterfaceDeclaration"
1173    // src/com/google/doclava/parser/Java.g:341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );
1174    public final void classOrInterfaceDeclaration() throws RecognitionException {
1175        int classOrInterfaceDeclaration_StartIndex = input.index();
1176        try { dbg.enterRule(getGrammarFileName(), "classOrInterfaceDeclaration");
1177        if ( getRuleLevel()==0 ) {dbg.commence();}
1178        incRuleLevel();
1179        dbg.location(341, 1);
1180
1181        try {
1182            if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return ; }
1183            // src/com/google/doclava/parser/Java.g:342:5: ( classDeclaration | interfaceDeclaration )
1184            int alt12=2;
1185            try { dbg.enterDecision(12, decisionCanBacktrack[12]);
1186
1187            try {
1188                isCyclicDecision = true;
1189                alt12 = dfa12.predict(input);
1190            }
1191            catch (NoViableAltException nvae) {
1192                dbg.recognitionException(nvae);
1193                throw nvae;
1194            }
1195            } finally {dbg.exitDecision(12);}
1196
1197            switch (alt12) {
1198                case 1 :
1199                    dbg.enterAlt(1);
1200
1201                    // src/com/google/doclava/parser/Java.g:342:10: classDeclaration
1202                    {
1203                    dbg.location(342,10);
1204                    pushFollow(FOLLOW_classDeclaration_in_classOrInterfaceDeclaration436);
1205                    classDeclaration();
1206
1207                    state._fsp--;
1208                    if (state.failed) return ;
1209
1210                    }
1211                    break;
1212                case 2 :
1213                    dbg.enterAlt(2);
1214
1215                    // src/com/google/doclava/parser/Java.g:343:9: interfaceDeclaration
1216                    {
1217                    dbg.location(343,9);
1218                    pushFollow(FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration446);
1219                    interfaceDeclaration();
1220
1221                    state._fsp--;
1222                    if (state.failed) return ;
1223
1224                    }
1225                    break;
1226
1227            }
1228        }
1229        catch (RecognitionException re) {
1230            reportError(re);
1231            recover(input,re);
1232        }
1233        finally {
1234            if ( state.backtracking>0 ) { memoize(input, 6, classOrInterfaceDeclaration_StartIndex); }
1235        }
1236        dbg.location(344, 5);
1237
1238        }
1239        finally {
1240            dbg.exitRule(getGrammarFileName(), "classOrInterfaceDeclaration");
1241            decRuleLevel();
1242            if ( getRuleLevel()==0 ) {dbg.terminate();}
1243        }
1244
1245        return ;
1246    }
1247    // $ANTLR end "classOrInterfaceDeclaration"
1248
1249
1250    // $ANTLR start "modifiers"
1251    // src/com/google/doclava/parser/Java.g:347:1: modifiers : ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* ;
1252    public final void modifiers() throws RecognitionException {
1253        int modifiers_StartIndex = input.index();
1254        try { dbg.enterRule(getGrammarFileName(), "modifiers");
1255        if ( getRuleLevel()==0 ) {dbg.commence();}
1256        incRuleLevel();
1257        dbg.location(347, 1);
1258
1259        try {
1260            if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return ; }
1261            // src/com/google/doclava/parser/Java.g:348:5: ( ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* )
1262            dbg.enterAlt(1);
1263
1264            // src/com/google/doclava/parser/Java.g:349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*
1265            {
1266            dbg.location(349,5);
1267            // src/com/google/doclava/parser/Java.g:349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*
1268            try { dbg.enterSubRule(13);
1269
1270            loop13:
1271            do {
1272                int alt13=13;
1273                try { dbg.enterDecision(13, decisionCanBacktrack[13]);
1274
1275                try {
1276                    isCyclicDecision = true;
1277                    alt13 = dfa13.predict(input);
1278                }
1279                catch (NoViableAltException nvae) {
1280                    dbg.recognitionException(nvae);
1281                    throw nvae;
1282                }
1283                } finally {dbg.exitDecision(13);}
1284
1285                switch (alt13) {
1286		case 1 :
1287		    dbg.enterAlt(1);
1288
1289		    // src/com/google/doclava/parser/Java.g:349:10: annotation
1290		    {
1291		    dbg.location(349,10);
1292		    pushFollow(FOLLOW_annotation_in_modifiers473);
1293		    annotation();
1294
1295		    state._fsp--;
1296		    if (state.failed) return ;
1297
1298		    }
1299		    break;
1300		case 2 :
1301		    dbg.enterAlt(2);
1302
1303		    // src/com/google/doclava/parser/Java.g:350:9: 'public'
1304		    {
1305		    dbg.location(350,9);
1306		    match(input,PUBLIC,FOLLOW_PUBLIC_in_modifiers483); if (state.failed) return ;
1307
1308		    }
1309		    break;
1310		case 3 :
1311		    dbg.enterAlt(3);
1312
1313		    // src/com/google/doclava/parser/Java.g:351:9: 'protected'
1314		    {
1315		    dbg.location(351,9);
1316		    match(input,PROTECTED,FOLLOW_PROTECTED_in_modifiers493); if (state.failed) return ;
1317
1318		    }
1319		    break;
1320		case 4 :
1321		    dbg.enterAlt(4);
1322
1323		    // src/com/google/doclava/parser/Java.g:352:9: 'private'
1324		    {
1325		    dbg.location(352,9);
1326		    match(input,PRIVATE,FOLLOW_PRIVATE_in_modifiers503); if (state.failed) return ;
1327
1328		    }
1329		    break;
1330		case 5 :
1331		    dbg.enterAlt(5);
1332
1333		    // src/com/google/doclava/parser/Java.g:353:9: 'static'
1334		    {
1335		    dbg.location(353,9);
1336		    match(input,STATIC,FOLLOW_STATIC_in_modifiers513); if (state.failed) return ;
1337
1338		    }
1339		    break;
1340		case 6 :
1341		    dbg.enterAlt(6);
1342
1343		    // src/com/google/doclava/parser/Java.g:354:9: 'abstract'
1344		    {
1345		    dbg.location(354,9);
1346		    match(input,ABSTRACT,FOLLOW_ABSTRACT_in_modifiers523); if (state.failed) return ;
1347
1348		    }
1349		    break;
1350		case 7 :
1351		    dbg.enterAlt(7);
1352
1353		    // src/com/google/doclava/parser/Java.g:355:9: 'final'
1354		    {
1355		    dbg.location(355,9);
1356		    match(input,FINAL,FOLLOW_FINAL_in_modifiers533); if (state.failed) return ;
1357
1358		    }
1359		    break;
1360		case 8 :
1361		    dbg.enterAlt(8);
1362
1363		    // src/com/google/doclava/parser/Java.g:356:9: 'native'
1364		    {
1365		    dbg.location(356,9);
1366		    match(input,NATIVE,FOLLOW_NATIVE_in_modifiers543); if (state.failed) return ;
1367
1368		    }
1369		    break;
1370		case 9 :
1371		    dbg.enterAlt(9);
1372
1373		    // src/com/google/doclava/parser/Java.g:357:9: 'synchronized'
1374		    {
1375		    dbg.location(357,9);
1376		    match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_modifiers553); if (state.failed) return ;
1377
1378		    }
1379		    break;
1380		case 10 :
1381		    dbg.enterAlt(10);
1382
1383		    // src/com/google/doclava/parser/Java.g:358:9: 'transient'
1384		    {
1385		    dbg.location(358,9);
1386		    match(input,TRANSIENT,FOLLOW_TRANSIENT_in_modifiers563); if (state.failed) return ;
1387
1388		    }
1389		    break;
1390		case 11 :
1391		    dbg.enterAlt(11);
1392
1393		    // src/com/google/doclava/parser/Java.g:359:9: 'volatile'
1394		    {
1395		    dbg.location(359,9);
1396		    match(input,VOLATILE,FOLLOW_VOLATILE_in_modifiers573); if (state.failed) return ;
1397
1398		    }
1399		    break;
1400		case 12 :
1401		    dbg.enterAlt(12);
1402
1403		    // src/com/google/doclava/parser/Java.g:360:9: 'strictfp'
1404		    {
1405		    dbg.location(360,9);
1406		    match(input,STRICTFP,FOLLOW_STRICTFP_in_modifiers583); if (state.failed) return ;
1407
1408		    }
1409		    break;
1410
1411		default :
1412		    break loop13;
1413                }
1414            } while (true);
1415            } finally {dbg.exitSubRule(13);}
1416
1417
1418            }
1419
1420        }
1421        catch (RecognitionException re) {
1422            reportError(re);
1423            recover(input,re);
1424        }
1425        finally {
1426            if ( state.backtracking>0 ) { memoize(input, 7, modifiers_StartIndex); }
1427        }
1428        dbg.location(362, 5);
1429
1430        }
1431        finally {
1432            dbg.exitRule(getGrammarFileName(), "modifiers");
1433            decRuleLevel();
1434            if ( getRuleLevel()==0 ) {dbg.terminate();}
1435        }
1436
1437        return ;
1438    }
1439    // $ANTLR end "modifiers"
1440
1441
1442    // $ANTLR start "variableModifiers"
1443    // src/com/google/doclava/parser/Java.g:365:1: variableModifiers : ( 'final' | annotation )* ;
1444    public final void variableModifiers() throws RecognitionException {
1445        int variableModifiers_StartIndex = input.index();
1446        try { dbg.enterRule(getGrammarFileName(), "variableModifiers");
1447        if ( getRuleLevel()==0 ) {dbg.commence();}
1448        incRuleLevel();
1449        dbg.location(365, 1);
1450
1451        try {
1452            if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return ; }
1453            // src/com/google/doclava/parser/Java.g:366:5: ( ( 'final' | annotation )* )
1454            dbg.enterAlt(1);
1455
1456            // src/com/google/doclava/parser/Java.g:366:9: ( 'final' | annotation )*
1457            {
1458            dbg.location(366,9);
1459            // src/com/google/doclava/parser/Java.g:366:9: ( 'final' | annotation )*
1460            try { dbg.enterSubRule(14);
1461
1462            loop14:
1463            do {
1464                int alt14=3;
1465                try { dbg.enterDecision(14, decisionCanBacktrack[14]);
1466
1467                int LA14_0 = input.LA(1);
1468
1469                if ( (LA14_0==FINAL) ) {
1470                    alt14=1;
1471                }
1472                else if ( (LA14_0==MONKEYS_AT) ) {
1473                    alt14=2;
1474                }
1475
1476
1477                } finally {dbg.exitDecision(14);}
1478
1479                switch (alt14) {
1480		case 1 :
1481		    dbg.enterAlt(1);
1482
1483		    // src/com/google/doclava/parser/Java.g:366:13: 'final'
1484		    {
1485		    dbg.location(366,13);
1486		    match(input,FINAL,FOLLOW_FINAL_in_variableModifiers614); if (state.failed) return ;
1487
1488		    }
1489		    break;
1490		case 2 :
1491		    dbg.enterAlt(2);
1492
1493		    // src/com/google/doclava/parser/Java.g:367:13: annotation
1494		    {
1495		    dbg.location(367,13);
1496		    pushFollow(FOLLOW_annotation_in_variableModifiers628);
1497		    annotation();
1498
1499		    state._fsp--;
1500		    if (state.failed) return ;
1501
1502		    }
1503		    break;
1504
1505		default :
1506		    break loop14;
1507                }
1508            } while (true);
1509            } finally {dbg.exitSubRule(14);}
1510
1511
1512            }
1513
1514        }
1515        catch (RecognitionException re) {
1516            reportError(re);
1517            recover(input,re);
1518        }
1519        finally {
1520            if ( state.backtracking>0 ) { memoize(input, 8, variableModifiers_StartIndex); }
1521        }
1522        dbg.location(369, 5);
1523
1524        }
1525        finally {
1526            dbg.exitRule(getGrammarFileName(), "variableModifiers");
1527            decRuleLevel();
1528            if ( getRuleLevel()==0 ) {dbg.terminate();}
1529        }
1530
1531        return ;
1532    }
1533    // $ANTLR end "variableModifiers"
1534
1535
1536    // $ANTLR start "classDeclaration"
1537    // src/com/google/doclava/parser/Java.g:372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );
1538    public final void classDeclaration() throws RecognitionException {
1539        int classDeclaration_StartIndex = input.index();
1540        try { dbg.enterRule(getGrammarFileName(), "classDeclaration");
1541        if ( getRuleLevel()==0 ) {dbg.commence();}
1542        incRuleLevel();
1543        dbg.location(372, 1);
1544
1545        try {
1546            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return ; }
1547            // src/com/google/doclava/parser/Java.g:373:5: ( normalClassDeclaration | enumDeclaration )
1548            int alt15=2;
1549            try { dbg.enterDecision(15, decisionCanBacktrack[15]);
1550
1551            try {
1552                isCyclicDecision = true;
1553                alt15 = dfa15.predict(input);
1554            }
1555            catch (NoViableAltException nvae) {
1556                dbg.recognitionException(nvae);
1557                throw nvae;
1558            }
1559            } finally {dbg.exitDecision(15);}
1560
1561            switch (alt15) {
1562                case 1 :
1563                    dbg.enterAlt(1);
1564
1565                    // src/com/google/doclava/parser/Java.g:373:9: normalClassDeclaration
1566                    {
1567                    dbg.location(373,9);
1568                    pushFollow(FOLLOW_normalClassDeclaration_in_classDeclaration659);
1569                    normalClassDeclaration();
1570
1571                    state._fsp--;
1572                    if (state.failed) return ;
1573
1574                    }
1575                    break;
1576                case 2 :
1577                    dbg.enterAlt(2);
1578
1579                    // src/com/google/doclava/parser/Java.g:374:9: enumDeclaration
1580                    {
1581                    dbg.location(374,9);
1582                    pushFollow(FOLLOW_enumDeclaration_in_classDeclaration669);
1583                    enumDeclaration();
1584
1585                    state._fsp--;
1586                    if (state.failed) return ;
1587
1588                    }
1589                    break;
1590
1591            }
1592        }
1593        catch (RecognitionException re) {
1594            reportError(re);
1595            recover(input,re);
1596        }
1597        finally {
1598            if ( state.backtracking>0 ) { memoize(input, 9, classDeclaration_StartIndex); }
1599        }
1600        dbg.location(375, 5);
1601
1602        }
1603        finally {
1604            dbg.exitRule(getGrammarFileName(), "classDeclaration");
1605            decRuleLevel();
1606            if ( getRuleLevel()==0 ) {dbg.terminate();}
1607        }
1608
1609        return ;
1610    }
1611    // $ANTLR end "classDeclaration"
1612
1613
1614    // $ANTLR start "normalClassDeclaration"
1615    // src/com/google/doclava/parser/Java.g:377:1: normalClassDeclaration : modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody ;
1616    public final void normalClassDeclaration() throws RecognitionException {
1617        int normalClassDeclaration_StartIndex = input.index();
1618        try { dbg.enterRule(getGrammarFileName(), "normalClassDeclaration");
1619        if ( getRuleLevel()==0 ) {dbg.commence();}
1620        incRuleLevel();
1621        dbg.location(377, 1);
1622
1623        try {
1624            if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return ; }
1625            // src/com/google/doclava/parser/Java.g:378:5: ( modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody )
1626            dbg.enterAlt(1);
1627
1628            // src/com/google/doclava/parser/Java.g:378:9: modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody
1629            {
1630            dbg.location(378,9);
1631            pushFollow(FOLLOW_modifiers_in_normalClassDeclaration688);
1632            modifiers();
1633
1634            state._fsp--;
1635            if (state.failed) return ;
1636            dbg.location(378,20);
1637            match(input,CLASS,FOLLOW_CLASS_in_normalClassDeclaration691); if (state.failed) return ;
1638            dbg.location(378,28);
1639            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalClassDeclaration693); if (state.failed) return ;
1640            dbg.location(379,9);
1641            // src/com/google/doclava/parser/Java.g:379:9: ( typeParameters )?
1642            int alt16=2;
1643            try { dbg.enterSubRule(16);
1644            try { dbg.enterDecision(16, decisionCanBacktrack[16]);
1645
1646            int LA16_0 = input.LA(1);
1647
1648            if ( (LA16_0==LT) ) {
1649                alt16=1;
1650            }
1651            } finally {dbg.exitDecision(16);}
1652
1653            switch (alt16) {
1654                case 1 :
1655                    dbg.enterAlt(1);
1656
1657                    // src/com/google/doclava/parser/Java.g:379:10: typeParameters
1658                    {
1659                    dbg.location(379,10);
1660                    pushFollow(FOLLOW_typeParameters_in_normalClassDeclaration704);
1661                    typeParameters();
1662
1663                    state._fsp--;
1664                    if (state.failed) return ;
1665
1666                    }
1667                    break;
1668
1669            }
1670            } finally {dbg.exitSubRule(16);}
1671
1672            dbg.location(381,9);
1673            // src/com/google/doclava/parser/Java.g:381:9: ( 'extends' type )?
1674            int alt17=2;
1675            try { dbg.enterSubRule(17);
1676            try { dbg.enterDecision(17, decisionCanBacktrack[17]);
1677
1678            int LA17_0 = input.LA(1);
1679
1680            if ( (LA17_0==EXTENDS) ) {
1681                alt17=1;
1682            }
1683            } finally {dbg.exitDecision(17);}
1684
1685            switch (alt17) {
1686                case 1 :
1687                    dbg.enterAlt(1);
1688
1689                    // src/com/google/doclava/parser/Java.g:381:10: 'extends' type
1690                    {
1691                    dbg.location(381,10);
1692                    match(input,EXTENDS,FOLLOW_EXTENDS_in_normalClassDeclaration726); if (state.failed) return ;
1693                    dbg.location(381,20);
1694                    pushFollow(FOLLOW_type_in_normalClassDeclaration728);
1695                    type();
1696
1697                    state._fsp--;
1698                    if (state.failed) return ;
1699
1700                    }
1701                    break;
1702
1703            }
1704            } finally {dbg.exitSubRule(17);}
1705
1706            dbg.location(383,9);
1707            // src/com/google/doclava/parser/Java.g:383:9: ( 'implements' typeList )?
1708            int alt18=2;
1709            try { dbg.enterSubRule(18);
1710            try { dbg.enterDecision(18, decisionCanBacktrack[18]);
1711
1712            int LA18_0 = input.LA(1);
1713
1714            if ( (LA18_0==IMPLEMENTS) ) {
1715                alt18=1;
1716            }
1717            } finally {dbg.exitDecision(18);}
1718
1719            switch (alt18) {
1720                case 1 :
1721                    dbg.enterAlt(1);
1722
1723                    // src/com/google/doclava/parser/Java.g:383:10: 'implements' typeList
1724                    {
1725                    dbg.location(383,10);
1726                    match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_normalClassDeclaration750); if (state.failed) return ;
1727                    dbg.location(383,23);
1728                    pushFollow(FOLLOW_typeList_in_normalClassDeclaration752);
1729                    typeList();
1730
1731                    state._fsp--;
1732                    if (state.failed) return ;
1733
1734                    }
1735                    break;
1736
1737            }
1738            } finally {dbg.exitSubRule(18);}
1739
1740            dbg.location(385,9);
1741            pushFollow(FOLLOW_classBody_in_normalClassDeclaration773);
1742            classBody();
1743
1744            state._fsp--;
1745            if (state.failed) return ;
1746
1747            }
1748
1749        }
1750        catch (RecognitionException re) {
1751            reportError(re);
1752            recover(input,re);
1753        }
1754        finally {
1755            if ( state.backtracking>0 ) { memoize(input, 10, normalClassDeclaration_StartIndex); }
1756        }
1757        dbg.location(386, 5);
1758
1759        }
1760        finally {
1761            dbg.exitRule(getGrammarFileName(), "normalClassDeclaration");
1762            decRuleLevel();
1763            if ( getRuleLevel()==0 ) {dbg.terminate();}
1764        }
1765
1766        return ;
1767    }
1768    // $ANTLR end "normalClassDeclaration"
1769
1770
1771    // $ANTLR start "typeParameters"
1772    // src/com/google/doclava/parser/Java.g:389:1: typeParameters : '<' typeParameter ( ',' typeParameter )* '>' ;
1773    public final void typeParameters() throws RecognitionException {
1774        int typeParameters_StartIndex = input.index();
1775        try { dbg.enterRule(getGrammarFileName(), "typeParameters");
1776        if ( getRuleLevel()==0 ) {dbg.commence();}
1777        incRuleLevel();
1778        dbg.location(389, 1);
1779
1780        try {
1781            if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return ; }
1782            // src/com/google/doclava/parser/Java.g:390:5: ( '<' typeParameter ( ',' typeParameter )* '>' )
1783            dbg.enterAlt(1);
1784
1785            // src/com/google/doclava/parser/Java.g:390:9: '<' typeParameter ( ',' typeParameter )* '>'
1786            {
1787            dbg.location(390,9);
1788            match(input,LT,FOLLOW_LT_in_typeParameters793); if (state.failed) return ;
1789            dbg.location(391,13);
1790            pushFollow(FOLLOW_typeParameter_in_typeParameters807);
1791            typeParameter();
1792
1793            state._fsp--;
1794            if (state.failed) return ;
1795            dbg.location(392,13);
1796            // src/com/google/doclava/parser/Java.g:392:13: ( ',' typeParameter )*
1797            try { dbg.enterSubRule(19);
1798
1799            loop19:
1800            do {
1801                int alt19=2;
1802                try { dbg.enterDecision(19, decisionCanBacktrack[19]);
1803
1804                int LA19_0 = input.LA(1);
1805
1806                if ( (LA19_0==COMMA) ) {
1807                    alt19=1;
1808                }
1809
1810
1811                } finally {dbg.exitDecision(19);}
1812
1813                switch (alt19) {
1814		case 1 :
1815		    dbg.enterAlt(1);
1816
1817		    // src/com/google/doclava/parser/Java.g:392:14: ',' typeParameter
1818		    {
1819		    dbg.location(392,14);
1820		    match(input,COMMA,FOLLOW_COMMA_in_typeParameters822); if (state.failed) return ;
1821		    dbg.location(392,18);
1822		    pushFollow(FOLLOW_typeParameter_in_typeParameters824);
1823		    typeParameter();
1824
1825		    state._fsp--;
1826		    if (state.failed) return ;
1827
1828		    }
1829		    break;
1830
1831		default :
1832		    break loop19;
1833                }
1834            } while (true);
1835            } finally {dbg.exitSubRule(19);}
1836
1837            dbg.location(394,9);
1838            match(input,GT,FOLLOW_GT_in_typeParameters849); if (state.failed) return ;
1839
1840            }
1841
1842        }
1843        catch (RecognitionException re) {
1844            reportError(re);
1845            recover(input,re);
1846        }
1847        finally {
1848            if ( state.backtracking>0 ) { memoize(input, 11, typeParameters_StartIndex); }
1849        }
1850        dbg.location(395, 5);
1851
1852        }
1853        finally {
1854            dbg.exitRule(getGrammarFileName(), "typeParameters");
1855            decRuleLevel();
1856            if ( getRuleLevel()==0 ) {dbg.terminate();}
1857        }
1858
1859        return ;
1860    }
1861    // $ANTLR end "typeParameters"
1862
1863
1864    // $ANTLR start "typeParameter"
1865    // src/com/google/doclava/parser/Java.g:397:1: typeParameter : IDENTIFIER ( 'extends' typeBound )? ;
1866    public final void typeParameter() throws RecognitionException {
1867        int typeParameter_StartIndex = input.index();
1868        try { dbg.enterRule(getGrammarFileName(), "typeParameter");
1869        if ( getRuleLevel()==0 ) {dbg.commence();}
1870        incRuleLevel();
1871        dbg.location(397, 1);
1872
1873        try {
1874            if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return ; }
1875            // src/com/google/doclava/parser/Java.g:398:5: ( IDENTIFIER ( 'extends' typeBound )? )
1876            dbg.enterAlt(1);
1877
1878            // src/com/google/doclava/parser/Java.g:398:9: IDENTIFIER ( 'extends' typeBound )?
1879            {
1880            dbg.location(398,9);
1881            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeParameter868); if (state.failed) return ;
1882            dbg.location(399,9);
1883            // src/com/google/doclava/parser/Java.g:399:9: ( 'extends' typeBound )?
1884            int alt20=2;
1885            try { dbg.enterSubRule(20);
1886            try { dbg.enterDecision(20, decisionCanBacktrack[20]);
1887
1888            int LA20_0 = input.LA(1);
1889
1890            if ( (LA20_0==EXTENDS) ) {
1891                alt20=1;
1892            }
1893            } finally {dbg.exitDecision(20);}
1894
1895            switch (alt20) {
1896                case 1 :
1897                    dbg.enterAlt(1);
1898
1899                    // src/com/google/doclava/parser/Java.g:399:10: 'extends' typeBound
1900                    {
1901                    dbg.location(399,10);
1902                    match(input,EXTENDS,FOLLOW_EXTENDS_in_typeParameter879); if (state.failed) return ;
1903                    dbg.location(399,20);
1904                    pushFollow(FOLLOW_typeBound_in_typeParameter881);
1905                    typeBound();
1906
1907                    state._fsp--;
1908                    if (state.failed) return ;
1909
1910                    }
1911                    break;
1912
1913            }
1914            } finally {dbg.exitSubRule(20);}
1915
1916
1917            }
1918
1919        }
1920        catch (RecognitionException re) {
1921            reportError(re);
1922            recover(input,re);
1923        }
1924        finally {
1925            if ( state.backtracking>0 ) { memoize(input, 12, typeParameter_StartIndex); }
1926        }
1927        dbg.location(401, 5);
1928
1929        }
1930        finally {
1931            dbg.exitRule(getGrammarFileName(), "typeParameter");
1932            decRuleLevel();
1933            if ( getRuleLevel()==0 ) {dbg.terminate();}
1934        }
1935
1936        return ;
1937    }
1938    // $ANTLR end "typeParameter"
1939
1940
1941    // $ANTLR start "typeBound"
1942    // src/com/google/doclava/parser/Java.g:404:1: typeBound : type ( '&' type )* ;
1943    public final void typeBound() throws RecognitionException {
1944        int typeBound_StartIndex = input.index();
1945        try { dbg.enterRule(getGrammarFileName(), "typeBound");
1946        if ( getRuleLevel()==0 ) {dbg.commence();}
1947        incRuleLevel();
1948        dbg.location(404, 1);
1949
1950        try {
1951            if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return ; }
1952            // src/com/google/doclava/parser/Java.g:405:5: ( type ( '&' type )* )
1953            dbg.enterAlt(1);
1954
1955            // src/com/google/doclava/parser/Java.g:405:9: type ( '&' type )*
1956            {
1957            dbg.location(405,9);
1958            pushFollow(FOLLOW_type_in_typeBound912);
1959            type();
1960
1961            state._fsp--;
1962            if (state.failed) return ;
1963            dbg.location(406,9);
1964            // src/com/google/doclava/parser/Java.g:406:9: ( '&' type )*
1965            try { dbg.enterSubRule(21);
1966
1967            loop21:
1968            do {
1969                int alt21=2;
1970                try { dbg.enterDecision(21, decisionCanBacktrack[21]);
1971
1972                int LA21_0 = input.LA(1);
1973
1974                if ( (LA21_0==AMP) ) {
1975                    alt21=1;
1976                }
1977
1978
1979                } finally {dbg.exitDecision(21);}
1980
1981                switch (alt21) {
1982		case 1 :
1983		    dbg.enterAlt(1);
1984
1985		    // src/com/google/doclava/parser/Java.g:406:10: '&' type
1986		    {
1987		    dbg.location(406,10);
1988		    match(input,AMP,FOLLOW_AMP_in_typeBound923); if (state.failed) return ;
1989		    dbg.location(406,14);
1990		    pushFollow(FOLLOW_type_in_typeBound925);
1991		    type();
1992
1993		    state._fsp--;
1994		    if (state.failed) return ;
1995
1996		    }
1997		    break;
1998
1999		default :
2000		    break loop21;
2001                }
2002            } while (true);
2003            } finally {dbg.exitSubRule(21);}
2004
2005
2006            }
2007
2008        }
2009        catch (RecognitionException re) {
2010            reportError(re);
2011            recover(input,re);
2012        }
2013        finally {
2014            if ( state.backtracking>0 ) { memoize(input, 13, typeBound_StartIndex); }
2015        }
2016        dbg.location(408, 5);
2017
2018        }
2019        finally {
2020            dbg.exitRule(getGrammarFileName(), "typeBound");
2021            decRuleLevel();
2022            if ( getRuleLevel()==0 ) {dbg.terminate();}
2023        }
2024
2025        return ;
2026    }
2027    // $ANTLR end "typeBound"
2028
2029
2030    // $ANTLR start "enumDeclaration"
2031    // src/com/google/doclava/parser/Java.g:411:1: enumDeclaration : modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody ;
2032    public final void enumDeclaration() throws RecognitionException {
2033        int enumDeclaration_StartIndex = input.index();
2034        try { dbg.enterRule(getGrammarFileName(), "enumDeclaration");
2035        if ( getRuleLevel()==0 ) {dbg.commence();}
2036        incRuleLevel();
2037        dbg.location(411, 1);
2038
2039        try {
2040            if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return ; }
2041            // src/com/google/doclava/parser/Java.g:412:5: ( modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody )
2042            dbg.enterAlt(1);
2043
2044            // src/com/google/doclava/parser/Java.g:412:9: modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody
2045            {
2046            dbg.location(412,9);
2047            pushFollow(FOLLOW_modifiers_in_enumDeclaration956);
2048            modifiers();
2049
2050            state._fsp--;
2051            if (state.failed) return ;
2052            dbg.location(413,9);
2053            // src/com/google/doclava/parser/Java.g:413:9: ( 'enum' )
2054            dbg.enterAlt(1);
2055
2056            // src/com/google/doclava/parser/Java.g:413:10: 'enum'
2057            {
2058            dbg.location(413,10);
2059            match(input,ENUM,FOLLOW_ENUM_in_enumDeclaration967); if (state.failed) return ;
2060
2061            }
2062
2063            dbg.location(415,9);
2064            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumDeclaration987); if (state.failed) return ;
2065            dbg.location(416,9);
2066            // src/com/google/doclava/parser/Java.g:416:9: ( 'implements' typeList )?
2067            int alt22=2;
2068            try { dbg.enterSubRule(22);
2069            try { dbg.enterDecision(22, decisionCanBacktrack[22]);
2070
2071            int LA22_0 = input.LA(1);
2072
2073            if ( (LA22_0==IMPLEMENTS) ) {
2074                alt22=1;
2075            }
2076            } finally {dbg.exitDecision(22);}
2077
2078            switch (alt22) {
2079                case 1 :
2080                    dbg.enterAlt(1);
2081
2082                    // src/com/google/doclava/parser/Java.g:416:10: 'implements' typeList
2083                    {
2084                    dbg.location(416,10);
2085                    match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_enumDeclaration998); if (state.failed) return ;
2086                    dbg.location(416,23);
2087                    pushFollow(FOLLOW_typeList_in_enumDeclaration1000);
2088                    typeList();
2089
2090                    state._fsp--;
2091                    if (state.failed) return ;
2092
2093                    }
2094                    break;
2095
2096            }
2097            } finally {dbg.exitSubRule(22);}
2098
2099            dbg.location(418,9);
2100            pushFollow(FOLLOW_enumBody_in_enumDeclaration1021);
2101            enumBody();
2102
2103            state._fsp--;
2104            if (state.failed) return ;
2105
2106            }
2107
2108        }
2109        catch (RecognitionException re) {
2110            reportError(re);
2111            recover(input,re);
2112        }
2113        finally {
2114            if ( state.backtracking>0 ) { memoize(input, 14, enumDeclaration_StartIndex); }
2115        }
2116        dbg.location(419, 5);
2117
2118        }
2119        finally {
2120            dbg.exitRule(getGrammarFileName(), "enumDeclaration");
2121            decRuleLevel();
2122            if ( getRuleLevel()==0 ) {dbg.terminate();}
2123        }
2124
2125        return ;
2126    }
2127    // $ANTLR end "enumDeclaration"
2128
2129
2130    // $ANTLR start "enumBody"
2131    // src/com/google/doclava/parser/Java.g:422:1: enumBody : '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' ;
2132    public final void enumBody() throws RecognitionException {
2133        int enumBody_StartIndex = input.index();
2134        try { dbg.enterRule(getGrammarFileName(), "enumBody");
2135        if ( getRuleLevel()==0 ) {dbg.commence();}
2136        incRuleLevel();
2137        dbg.location(422, 1);
2138
2139        try {
2140            if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return ; }
2141            // src/com/google/doclava/parser/Java.g:423:5: ( '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' )
2142            dbg.enterAlt(1);
2143
2144            // src/com/google/doclava/parser/Java.g:423:9: '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}'
2145            {
2146            dbg.location(423,9);
2147            match(input,LBRACE,FOLLOW_LBRACE_in_enumBody1041); if (state.failed) return ;
2148            dbg.location(424,9);
2149            // src/com/google/doclava/parser/Java.g:424:9: ( enumConstants )?
2150            int alt23=2;
2151            try { dbg.enterSubRule(23);
2152            try { dbg.enterDecision(23, decisionCanBacktrack[23]);
2153
2154            int LA23_0 = input.LA(1);
2155
2156            if ( (LA23_0==IDENTIFIER||LA23_0==MONKEYS_AT) ) {
2157                alt23=1;
2158            }
2159            } finally {dbg.exitDecision(23);}
2160
2161            switch (alt23) {
2162                case 1 :
2163                    dbg.enterAlt(1);
2164
2165                    // src/com/google/doclava/parser/Java.g:424:10: enumConstants
2166                    {
2167                    dbg.location(424,10);
2168                    pushFollow(FOLLOW_enumConstants_in_enumBody1052);
2169                    enumConstants();
2170
2171                    state._fsp--;
2172                    if (state.failed) return ;
2173
2174                    }
2175                    break;
2176
2177            }
2178            } finally {dbg.exitSubRule(23);}
2179
2180            dbg.location(426,9);
2181            // src/com/google/doclava/parser/Java.g:426:9: ( ',' )?
2182            int alt24=2;
2183            try { dbg.enterSubRule(24);
2184            try { dbg.enterDecision(24, decisionCanBacktrack[24]);
2185
2186            int LA24_0 = input.LA(1);
2187
2188            if ( (LA24_0==COMMA) ) {
2189                alt24=1;
2190            }
2191            } finally {dbg.exitDecision(24);}
2192
2193            switch (alt24) {
2194                case 1 :
2195                    dbg.enterAlt(1);
2196
2197                    // src/com/google/doclava/parser/Java.g:0:0: ','
2198                    {
2199                    dbg.location(426,9);
2200                    match(input,COMMA,FOLLOW_COMMA_in_enumBody1073); if (state.failed) return ;
2201
2202                    }
2203                    break;
2204
2205            }
2206            } finally {dbg.exitSubRule(24);}
2207
2208            dbg.location(427,9);
2209            // src/com/google/doclava/parser/Java.g:427:9: ( enumBodyDeclarations )?
2210            int alt25=2;
2211            try { dbg.enterSubRule(25);
2212            try { dbg.enterDecision(25, decisionCanBacktrack[25]);
2213
2214            int LA25_0 = input.LA(1);
2215
2216            if ( (LA25_0==SEMI) ) {
2217                alt25=1;
2218            }
2219            } finally {dbg.exitDecision(25);}
2220
2221            switch (alt25) {
2222                case 1 :
2223                    dbg.enterAlt(1);
2224
2225                    // src/com/google/doclava/parser/Java.g:427:10: enumBodyDeclarations
2226                    {
2227                    dbg.location(427,10);
2228                    pushFollow(FOLLOW_enumBodyDeclarations_in_enumBody1085);
2229                    enumBodyDeclarations();
2230
2231                    state._fsp--;
2232                    if (state.failed) return ;
2233
2234                    }
2235                    break;
2236
2237            }
2238            } finally {dbg.exitSubRule(25);}
2239
2240            dbg.location(429,9);
2241            match(input,RBRACE,FOLLOW_RBRACE_in_enumBody1106); if (state.failed) return ;
2242
2243            }
2244
2245        }
2246        catch (RecognitionException re) {
2247            reportError(re);
2248            recover(input,re);
2249        }
2250        finally {
2251            if ( state.backtracking>0 ) { memoize(input, 15, enumBody_StartIndex); }
2252        }
2253        dbg.location(430, 5);
2254
2255        }
2256        finally {
2257            dbg.exitRule(getGrammarFileName(), "enumBody");
2258            decRuleLevel();
2259            if ( getRuleLevel()==0 ) {dbg.terminate();}
2260        }
2261
2262        return ;
2263    }
2264    // $ANTLR end "enumBody"
2265
2266
2267    // $ANTLR start "enumConstants"
2268    // src/com/google/doclava/parser/Java.g:432:1: enumConstants : enumConstant ( ',' enumConstant )* ;
2269    public final void enumConstants() throws RecognitionException {
2270        int enumConstants_StartIndex = input.index();
2271        try { dbg.enterRule(getGrammarFileName(), "enumConstants");
2272        if ( getRuleLevel()==0 ) {dbg.commence();}
2273        incRuleLevel();
2274        dbg.location(432, 1);
2275
2276        try {
2277            if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return ; }
2278            // src/com/google/doclava/parser/Java.g:433:5: ( enumConstant ( ',' enumConstant )* )
2279            dbg.enterAlt(1);
2280
2281            // src/com/google/doclava/parser/Java.g:433:9: enumConstant ( ',' enumConstant )*
2282            {
2283            dbg.location(433,9);
2284            pushFollow(FOLLOW_enumConstant_in_enumConstants1125);
2285            enumConstant();
2286
2287            state._fsp--;
2288            if (state.failed) return ;
2289            dbg.location(434,9);
2290            // src/com/google/doclava/parser/Java.g:434:9: ( ',' enumConstant )*
2291            try { dbg.enterSubRule(26);
2292
2293            loop26:
2294            do {
2295                int alt26=2;
2296                try { dbg.enterDecision(26, decisionCanBacktrack[26]);
2297
2298                int LA26_0 = input.LA(1);
2299
2300                if ( (LA26_0==COMMA) ) {
2301                    int LA26_1 = input.LA(2);
2302
2303                    if ( (LA26_1==IDENTIFIER||LA26_1==MONKEYS_AT) ) {
2304                        alt26=1;
2305                    }
2306
2307
2308                }
2309
2310
2311                } finally {dbg.exitDecision(26);}
2312
2313                switch (alt26) {
2314		case 1 :
2315		    dbg.enterAlt(1);
2316
2317		    // src/com/google/doclava/parser/Java.g:434:10: ',' enumConstant
2318		    {
2319		    dbg.location(434,10);
2320		    match(input,COMMA,FOLLOW_COMMA_in_enumConstants1136); if (state.failed) return ;
2321		    dbg.location(434,14);
2322		    pushFollow(FOLLOW_enumConstant_in_enumConstants1138);
2323		    enumConstant();
2324
2325		    state._fsp--;
2326		    if (state.failed) return ;
2327
2328		    }
2329		    break;
2330
2331		default :
2332		    break loop26;
2333                }
2334            } while (true);
2335            } finally {dbg.exitSubRule(26);}
2336
2337
2338            }
2339
2340        }
2341        catch (RecognitionException re) {
2342            reportError(re);
2343            recover(input,re);
2344        }
2345        finally {
2346            if ( state.backtracking>0 ) { memoize(input, 16, enumConstants_StartIndex); }
2347        }
2348        dbg.location(436, 5);
2349
2350        }
2351        finally {
2352            dbg.exitRule(getGrammarFileName(), "enumConstants");
2353            decRuleLevel();
2354            if ( getRuleLevel()==0 ) {dbg.terminate();}
2355        }
2356
2357        return ;
2358    }
2359    // $ANTLR end "enumConstants"
2360
2361
2362    // $ANTLR start "enumConstant"
2363    // src/com/google/doclava/parser/Java.g:438:1: enumConstant : ( annotations )? IDENTIFIER ( arguments )? ( classBody )? ;
2364    public final void enumConstant() throws RecognitionException {
2365        int enumConstant_StartIndex = input.index();
2366        try { dbg.enterRule(getGrammarFileName(), "enumConstant");
2367        if ( getRuleLevel()==0 ) {dbg.commence();}
2368        incRuleLevel();
2369        dbg.location(438, 1);
2370
2371        try {
2372            if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return ; }
2373            // src/com/google/doclava/parser/Java.g:443:5: ( ( annotations )? IDENTIFIER ( arguments )? ( classBody )? )
2374            dbg.enterAlt(1);
2375
2376            // src/com/google/doclava/parser/Java.g:443:9: ( annotations )? IDENTIFIER ( arguments )? ( classBody )?
2377            {
2378            dbg.location(443,9);
2379            // src/com/google/doclava/parser/Java.g:443:9: ( annotations )?
2380            int alt27=2;
2381            try { dbg.enterSubRule(27);
2382            try { dbg.enterDecision(27, decisionCanBacktrack[27]);
2383
2384            int LA27_0 = input.LA(1);
2385
2386            if ( (LA27_0==MONKEYS_AT) ) {
2387                alt27=1;
2388            }
2389            } finally {dbg.exitDecision(27);}
2390
2391            switch (alt27) {
2392                case 1 :
2393                    dbg.enterAlt(1);
2394
2395                    // src/com/google/doclava/parser/Java.g:443:10: annotations
2396                    {
2397                    dbg.location(443,10);
2398                    pushFollow(FOLLOW_annotations_in_enumConstant1171);
2399                    annotations();
2400
2401                    state._fsp--;
2402                    if (state.failed) return ;
2403
2404                    }
2405                    break;
2406
2407            }
2408            } finally {dbg.exitSubRule(27);}
2409
2410            dbg.location(445,9);
2411            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumConstant1192); if (state.failed) return ;
2412            dbg.location(446,9);
2413            // src/com/google/doclava/parser/Java.g:446:9: ( arguments )?
2414            int alt28=2;
2415            try { dbg.enterSubRule(28);
2416            try { dbg.enterDecision(28, decisionCanBacktrack[28]);
2417
2418            int LA28_0 = input.LA(1);
2419
2420            if ( (LA28_0==LPAREN) ) {
2421                alt28=1;
2422            }
2423            } finally {dbg.exitDecision(28);}
2424
2425            switch (alt28) {
2426                case 1 :
2427                    dbg.enterAlt(1);
2428
2429                    // src/com/google/doclava/parser/Java.g:446:10: arguments
2430                    {
2431                    dbg.location(446,10);
2432                    pushFollow(FOLLOW_arguments_in_enumConstant1203);
2433                    arguments();
2434
2435                    state._fsp--;
2436                    if (state.failed) return ;
2437
2438                    }
2439                    break;
2440
2441            }
2442            } finally {dbg.exitSubRule(28);}
2443
2444            dbg.location(448,9);
2445            // src/com/google/doclava/parser/Java.g:448:9: ( classBody )?
2446            int alt29=2;
2447            try { dbg.enterSubRule(29);
2448            try { dbg.enterDecision(29, decisionCanBacktrack[29]);
2449
2450            int LA29_0 = input.LA(1);
2451
2452            if ( (LA29_0==LBRACE) ) {
2453                alt29=1;
2454            }
2455            } finally {dbg.exitDecision(29);}
2456
2457            switch (alt29) {
2458                case 1 :
2459                    dbg.enterAlt(1);
2460
2461                    // src/com/google/doclava/parser/Java.g:448:10: classBody
2462                    {
2463                    dbg.location(448,10);
2464                    pushFollow(FOLLOW_classBody_in_enumConstant1225);
2465                    classBody();
2466
2467                    state._fsp--;
2468                    if (state.failed) return ;
2469
2470                    }
2471                    break;
2472
2473            }
2474            } finally {dbg.exitSubRule(29);}
2475
2476
2477            }
2478
2479        }
2480        catch (RecognitionException re) {
2481            reportError(re);
2482            recover(input,re);
2483        }
2484        finally {
2485            if ( state.backtracking>0 ) { memoize(input, 17, enumConstant_StartIndex); }
2486        }
2487        dbg.location(452, 5);
2488
2489        }
2490        finally {
2491            dbg.exitRule(getGrammarFileName(), "enumConstant");
2492            decRuleLevel();
2493            if ( getRuleLevel()==0 ) {dbg.terminate();}
2494        }
2495
2496        return ;
2497    }
2498    // $ANTLR end "enumConstant"
2499
2500
2501    // $ANTLR start "enumBodyDeclarations"
2502    // src/com/google/doclava/parser/Java.g:454:1: enumBodyDeclarations : ';' ( classBodyDeclaration )* ;
2503    public final void enumBodyDeclarations() throws RecognitionException {
2504        int enumBodyDeclarations_StartIndex = input.index();
2505        try { dbg.enterRule(getGrammarFileName(), "enumBodyDeclarations");
2506        if ( getRuleLevel()==0 ) {dbg.commence();}
2507        incRuleLevel();
2508        dbg.location(454, 1);
2509
2510        try {
2511            if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return ; }
2512            // src/com/google/doclava/parser/Java.g:455:5: ( ';' ( classBodyDeclaration )* )
2513            dbg.enterAlt(1);
2514
2515            // src/com/google/doclava/parser/Java.g:455:9: ';' ( classBodyDeclaration )*
2516            {
2517            dbg.location(455,9);
2518            match(input,SEMI,FOLLOW_SEMI_in_enumBodyDeclarations1265); if (state.failed) return ;
2519            dbg.location(456,9);
2520            // src/com/google/doclava/parser/Java.g:456:9: ( classBodyDeclaration )*
2521            try { dbg.enterSubRule(30);
2522
2523            loop30:
2524            do {
2525                int alt30=2;
2526                try { dbg.enterDecision(30, decisionCanBacktrack[30]);
2527
2528                int LA30_0 = input.LA(1);
2529
2530                if ( (LA30_0==IDENTIFIER||LA30_0==ABSTRACT||LA30_0==BOOLEAN||LA30_0==BYTE||(LA30_0>=CHAR && LA30_0<=CLASS)||LA30_0==DOUBLE||LA30_0==ENUM||LA30_0==FINAL||LA30_0==FLOAT||(LA30_0>=INT && LA30_0<=NATIVE)||(LA30_0>=PRIVATE && LA30_0<=PUBLIC)||(LA30_0>=SHORT && LA30_0<=STRICTFP)||LA30_0==SYNCHRONIZED||LA30_0==TRANSIENT||(LA30_0>=VOID && LA30_0<=VOLATILE)||LA30_0==LBRACE||LA30_0==SEMI||LA30_0==MONKEYS_AT||LA30_0==LT) ) {
2531                    alt30=1;
2532                }
2533
2534
2535                } finally {dbg.exitDecision(30);}
2536
2537                switch (alt30) {
2538		case 1 :
2539		    dbg.enterAlt(1);
2540
2541		    // src/com/google/doclava/parser/Java.g:456:10: classBodyDeclaration
2542		    {
2543		    dbg.location(456,10);
2544		    pushFollow(FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1276);
2545		    classBodyDeclaration();
2546
2547		    state._fsp--;
2548		    if (state.failed) return ;
2549
2550		    }
2551		    break;
2552
2553		default :
2554		    break loop30;
2555                }
2556            } while (true);
2557            } finally {dbg.exitSubRule(30);}
2558
2559
2560            }
2561
2562        }
2563        catch (RecognitionException re) {
2564            reportError(re);
2565            recover(input,re);
2566        }
2567        finally {
2568            if ( state.backtracking>0 ) { memoize(input, 18, enumBodyDeclarations_StartIndex); }
2569        }
2570        dbg.location(458, 5);
2571
2572        }
2573        finally {
2574            dbg.exitRule(getGrammarFileName(), "enumBodyDeclarations");
2575            decRuleLevel();
2576            if ( getRuleLevel()==0 ) {dbg.terminate();}
2577        }
2578
2579        return ;
2580    }
2581    // $ANTLR end "enumBodyDeclarations"
2582
2583
2584    // $ANTLR start "interfaceDeclaration"
2585    // src/com/google/doclava/parser/Java.g:460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );
2586    public final void interfaceDeclaration() throws RecognitionException {
2587        int interfaceDeclaration_StartIndex = input.index();
2588        try { dbg.enterRule(getGrammarFileName(), "interfaceDeclaration");
2589        if ( getRuleLevel()==0 ) {dbg.commence();}
2590        incRuleLevel();
2591        dbg.location(460, 1);
2592
2593        try {
2594            if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return ; }
2595            // src/com/google/doclava/parser/Java.g:461:5: ( normalInterfaceDeclaration | annotationTypeDeclaration )
2596            int alt31=2;
2597            try { dbg.enterDecision(31, decisionCanBacktrack[31]);
2598
2599            try {
2600                isCyclicDecision = true;
2601                alt31 = dfa31.predict(input);
2602            }
2603            catch (NoViableAltException nvae) {
2604                dbg.recognitionException(nvae);
2605                throw nvae;
2606            }
2607            } finally {dbg.exitDecision(31);}
2608
2609            switch (alt31) {
2610                case 1 :
2611                    dbg.enterAlt(1);
2612
2613                    // src/com/google/doclava/parser/Java.g:461:9: normalInterfaceDeclaration
2614                    {
2615                    dbg.location(461,9);
2616                    pushFollow(FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1306);
2617                    normalInterfaceDeclaration();
2618
2619                    state._fsp--;
2620                    if (state.failed) return ;
2621
2622                    }
2623                    break;
2624                case 2 :
2625                    dbg.enterAlt(2);
2626
2627                    // src/com/google/doclava/parser/Java.g:462:9: annotationTypeDeclaration
2628                    {
2629                    dbg.location(462,9);
2630                    pushFollow(FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1316);
2631                    annotationTypeDeclaration();
2632
2633                    state._fsp--;
2634                    if (state.failed) return ;
2635
2636                    }
2637                    break;
2638
2639            }
2640        }
2641        catch (RecognitionException re) {
2642            reportError(re);
2643            recover(input,re);
2644        }
2645        finally {
2646            if ( state.backtracking>0 ) { memoize(input, 19, interfaceDeclaration_StartIndex); }
2647        }
2648        dbg.location(463, 5);
2649
2650        }
2651        finally {
2652            dbg.exitRule(getGrammarFileName(), "interfaceDeclaration");
2653            decRuleLevel();
2654            if ( getRuleLevel()==0 ) {dbg.terminate();}
2655        }
2656
2657        return ;
2658    }
2659    // $ANTLR end "interfaceDeclaration"
2660
2661
2662    // $ANTLR start "normalInterfaceDeclaration"
2663    // src/com/google/doclava/parser/Java.g:465:1: normalInterfaceDeclaration : modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody ;
2664    public final void normalInterfaceDeclaration() throws RecognitionException {
2665        int normalInterfaceDeclaration_StartIndex = input.index();
2666        try { dbg.enterRule(getGrammarFileName(), "normalInterfaceDeclaration");
2667        if ( getRuleLevel()==0 ) {dbg.commence();}
2668        incRuleLevel();
2669        dbg.location(465, 1);
2670
2671        try {
2672            if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return ; }
2673            // src/com/google/doclava/parser/Java.g:466:5: ( modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody )
2674            dbg.enterAlt(1);
2675
2676            // src/com/google/doclava/parser/Java.g:466:9: modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody
2677            {
2678            dbg.location(466,9);
2679            pushFollow(FOLLOW_modifiers_in_normalInterfaceDeclaration1335);
2680            modifiers();
2681
2682            state._fsp--;
2683            if (state.failed) return ;
2684            dbg.location(466,19);
2685            match(input,INTERFACE,FOLLOW_INTERFACE_in_normalInterfaceDeclaration1337); if (state.failed) return ;
2686            dbg.location(466,31);
2687            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1339); if (state.failed) return ;
2688            dbg.location(467,9);
2689            // src/com/google/doclava/parser/Java.g:467:9: ( typeParameters )?
2690            int alt32=2;
2691            try { dbg.enterSubRule(32);
2692            try { dbg.enterDecision(32, decisionCanBacktrack[32]);
2693
2694            int LA32_0 = input.LA(1);
2695
2696            if ( (LA32_0==LT) ) {
2697                alt32=1;
2698            }
2699            } finally {dbg.exitDecision(32);}
2700
2701            switch (alt32) {
2702                case 1 :
2703                    dbg.enterAlt(1);
2704
2705                    // src/com/google/doclava/parser/Java.g:467:10: typeParameters
2706                    {
2707                    dbg.location(467,10);
2708                    pushFollow(FOLLOW_typeParameters_in_normalInterfaceDeclaration1350);
2709                    typeParameters();
2710
2711                    state._fsp--;
2712                    if (state.failed) return ;
2713
2714                    }
2715                    break;
2716
2717            }
2718            } finally {dbg.exitSubRule(32);}
2719
2720            dbg.location(469,9);
2721            // src/com/google/doclava/parser/Java.g:469:9: ( 'extends' typeList )?
2722            int alt33=2;
2723            try { dbg.enterSubRule(33);
2724            try { dbg.enterDecision(33, decisionCanBacktrack[33]);
2725
2726            int LA33_0 = input.LA(1);
2727
2728            if ( (LA33_0==EXTENDS) ) {
2729                alt33=1;
2730            }
2731            } finally {dbg.exitDecision(33);}
2732
2733            switch (alt33) {
2734                case 1 :
2735                    dbg.enterAlt(1);
2736
2737                    // src/com/google/doclava/parser/Java.g:469:10: 'extends' typeList
2738                    {
2739                    dbg.location(469,10);
2740                    match(input,EXTENDS,FOLLOW_EXTENDS_in_normalInterfaceDeclaration1372); if (state.failed) return ;
2741                    dbg.location(469,20);
2742                    pushFollow(FOLLOW_typeList_in_normalInterfaceDeclaration1374);
2743                    typeList();
2744
2745                    state._fsp--;
2746                    if (state.failed) return ;
2747
2748                    }
2749                    break;
2750
2751            }
2752            } finally {dbg.exitSubRule(33);}
2753
2754            dbg.location(471,9);
2755            pushFollow(FOLLOW_interfaceBody_in_normalInterfaceDeclaration1395);
2756            interfaceBody();
2757
2758            state._fsp--;
2759            if (state.failed) return ;
2760
2761            }
2762
2763        }
2764        catch (RecognitionException re) {
2765            reportError(re);
2766            recover(input,re);
2767        }
2768        finally {
2769            if ( state.backtracking>0 ) { memoize(input, 20, normalInterfaceDeclaration_StartIndex); }
2770        }
2771        dbg.location(472, 5);
2772
2773        }
2774        finally {
2775            dbg.exitRule(getGrammarFileName(), "normalInterfaceDeclaration");
2776            decRuleLevel();
2777            if ( getRuleLevel()==0 ) {dbg.terminate();}
2778        }
2779
2780        return ;
2781    }
2782    // $ANTLR end "normalInterfaceDeclaration"
2783
2784
2785    // $ANTLR start "typeList"
2786    // src/com/google/doclava/parser/Java.g:474:1: typeList : type ( ',' type )* ;
2787    public final void typeList() throws RecognitionException {
2788        int typeList_StartIndex = input.index();
2789        try { dbg.enterRule(getGrammarFileName(), "typeList");
2790        if ( getRuleLevel()==0 ) {dbg.commence();}
2791        incRuleLevel();
2792        dbg.location(474, 1);
2793
2794        try {
2795            if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return ; }
2796            // src/com/google/doclava/parser/Java.g:475:5: ( type ( ',' type )* )
2797            dbg.enterAlt(1);
2798
2799            // src/com/google/doclava/parser/Java.g:475:9: type ( ',' type )*
2800            {
2801            dbg.location(475,9);
2802            pushFollow(FOLLOW_type_in_typeList1414);
2803            type();
2804
2805            state._fsp--;
2806            if (state.failed) return ;
2807            dbg.location(476,9);
2808            // src/com/google/doclava/parser/Java.g:476:9: ( ',' type )*
2809            try { dbg.enterSubRule(34);
2810
2811            loop34:
2812            do {
2813                int alt34=2;
2814                try { dbg.enterDecision(34, decisionCanBacktrack[34]);
2815
2816                int LA34_0 = input.LA(1);
2817
2818                if ( (LA34_0==COMMA) ) {
2819                    alt34=1;
2820                }
2821
2822
2823                } finally {dbg.exitDecision(34);}
2824
2825                switch (alt34) {
2826		case 1 :
2827		    dbg.enterAlt(1);
2828
2829		    // src/com/google/doclava/parser/Java.g:476:10: ',' type
2830		    {
2831		    dbg.location(476,10);
2832		    match(input,COMMA,FOLLOW_COMMA_in_typeList1425); if (state.failed) return ;
2833		    dbg.location(476,14);
2834		    pushFollow(FOLLOW_type_in_typeList1427);
2835		    type();
2836
2837		    state._fsp--;
2838		    if (state.failed) return ;
2839
2840		    }
2841		    break;
2842
2843		default :
2844		    break loop34;
2845                }
2846            } while (true);
2847            } finally {dbg.exitSubRule(34);}
2848
2849
2850            }
2851
2852        }
2853        catch (RecognitionException re) {
2854            reportError(re);
2855            recover(input,re);
2856        }
2857        finally {
2858            if ( state.backtracking>0 ) { memoize(input, 21, typeList_StartIndex); }
2859        }
2860        dbg.location(478, 5);
2861
2862        }
2863        finally {
2864            dbg.exitRule(getGrammarFileName(), "typeList");
2865            decRuleLevel();
2866            if ( getRuleLevel()==0 ) {dbg.terminate();}
2867        }
2868
2869        return ;
2870    }
2871    // $ANTLR end "typeList"
2872
2873
2874    // $ANTLR start "classBody"
2875    // src/com/google/doclava/parser/Java.g:480:1: classBody : '{' ( classBodyDeclaration )* '}' ;
2876    public final void classBody() throws RecognitionException {
2877        int classBody_StartIndex = input.index();
2878        try { dbg.enterRule(getGrammarFileName(), "classBody");
2879        if ( getRuleLevel()==0 ) {dbg.commence();}
2880        incRuleLevel();
2881        dbg.location(480, 1);
2882
2883        try {
2884            if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return ; }
2885            // src/com/google/doclava/parser/Java.g:481:5: ( '{' ( classBodyDeclaration )* '}' )
2886            dbg.enterAlt(1);
2887
2888            // src/com/google/doclava/parser/Java.g:481:9: '{' ( classBodyDeclaration )* '}'
2889            {
2890            dbg.location(481,9);
2891            match(input,LBRACE,FOLLOW_LBRACE_in_classBody1457); if (state.failed) return ;
2892            dbg.location(482,9);
2893            // src/com/google/doclava/parser/Java.g:482:9: ( classBodyDeclaration )*
2894            try { dbg.enterSubRule(35);
2895
2896            loop35:
2897            do {
2898                int alt35=2;
2899                try { dbg.enterDecision(35, decisionCanBacktrack[35]);
2900
2901                int LA35_0 = input.LA(1);
2902
2903                if ( (LA35_0==IDENTIFIER||LA35_0==ABSTRACT||LA35_0==BOOLEAN||LA35_0==BYTE||(LA35_0>=CHAR && LA35_0<=CLASS)||LA35_0==DOUBLE||LA35_0==ENUM||LA35_0==FINAL||LA35_0==FLOAT||(LA35_0>=INT && LA35_0<=NATIVE)||(LA35_0>=PRIVATE && LA35_0<=PUBLIC)||(LA35_0>=SHORT && LA35_0<=STRICTFP)||LA35_0==SYNCHRONIZED||LA35_0==TRANSIENT||(LA35_0>=VOID && LA35_0<=VOLATILE)||LA35_0==LBRACE||LA35_0==SEMI||LA35_0==MONKEYS_AT||LA35_0==LT) ) {
2904                    alt35=1;
2905                }
2906
2907
2908                } finally {dbg.exitDecision(35);}
2909
2910                switch (alt35) {
2911		case 1 :
2912		    dbg.enterAlt(1);
2913
2914		    // src/com/google/doclava/parser/Java.g:482:10: classBodyDeclaration
2915		    {
2916		    dbg.location(482,10);
2917		    pushFollow(FOLLOW_classBodyDeclaration_in_classBody1468);
2918		    classBodyDeclaration();
2919
2920		    state._fsp--;
2921		    if (state.failed) return ;
2922
2923		    }
2924		    break;
2925
2926		default :
2927		    break loop35;
2928                }
2929            } while (true);
2930            } finally {dbg.exitSubRule(35);}
2931
2932            dbg.location(484,9);
2933            match(input,RBRACE,FOLLOW_RBRACE_in_classBody1489); if (state.failed) return ;
2934
2935            }
2936
2937        }
2938        catch (RecognitionException re) {
2939            reportError(re);
2940            recover(input,re);
2941        }
2942        finally {
2943            if ( state.backtracking>0 ) { memoize(input, 22, classBody_StartIndex); }
2944        }
2945        dbg.location(485, 5);
2946
2947        }
2948        finally {
2949            dbg.exitRule(getGrammarFileName(), "classBody");
2950            decRuleLevel();
2951            if ( getRuleLevel()==0 ) {dbg.terminate();}
2952        }
2953
2954        return ;
2955    }
2956    // $ANTLR end "classBody"
2957
2958
2959    // $ANTLR start "interfaceBody"
2960    // src/com/google/doclava/parser/Java.g:487:1: interfaceBody : '{' ( interfaceBodyDeclaration )* '}' ;
2961    public final void interfaceBody() throws RecognitionException {
2962        int interfaceBody_StartIndex = input.index();
2963        try { dbg.enterRule(getGrammarFileName(), "interfaceBody");
2964        if ( getRuleLevel()==0 ) {dbg.commence();}
2965        incRuleLevel();
2966        dbg.location(487, 1);
2967
2968        try {
2969            if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return ; }
2970            // src/com/google/doclava/parser/Java.g:488:5: ( '{' ( interfaceBodyDeclaration )* '}' )
2971            dbg.enterAlt(1);
2972
2973            // src/com/google/doclava/parser/Java.g:488:9: '{' ( interfaceBodyDeclaration )* '}'
2974            {
2975            dbg.location(488,9);
2976            match(input,LBRACE,FOLLOW_LBRACE_in_interfaceBody1508); if (state.failed) return ;
2977            dbg.location(489,9);
2978            // src/com/google/doclava/parser/Java.g:489:9: ( interfaceBodyDeclaration )*
2979            try { dbg.enterSubRule(36);
2980
2981            loop36:
2982            do {
2983                int alt36=2;
2984                try { dbg.enterDecision(36, decisionCanBacktrack[36]);
2985
2986                int LA36_0 = input.LA(1);
2987
2988                if ( (LA36_0==IDENTIFIER||LA36_0==ABSTRACT||LA36_0==BOOLEAN||LA36_0==BYTE||(LA36_0>=CHAR && LA36_0<=CLASS)||LA36_0==DOUBLE||LA36_0==ENUM||LA36_0==FINAL||LA36_0==FLOAT||(LA36_0>=INT && LA36_0<=NATIVE)||(LA36_0>=PRIVATE && LA36_0<=PUBLIC)||(LA36_0>=SHORT && LA36_0<=STRICTFP)||LA36_0==SYNCHRONIZED||LA36_0==TRANSIENT||(LA36_0>=VOID && LA36_0<=VOLATILE)||LA36_0==SEMI||LA36_0==MONKEYS_AT||LA36_0==LT) ) {
2989                    alt36=1;
2990                }
2991
2992
2993                } finally {dbg.exitDecision(36);}
2994
2995                switch (alt36) {
2996		case 1 :
2997		    dbg.enterAlt(1);
2998
2999		    // src/com/google/doclava/parser/Java.g:489:10: interfaceBodyDeclaration
3000		    {
3001		    dbg.location(489,10);
3002		    pushFollow(FOLLOW_interfaceBodyDeclaration_in_interfaceBody1519);
3003		    interfaceBodyDeclaration();
3004
3005		    state._fsp--;
3006		    if (state.failed) return ;
3007
3008		    }
3009		    break;
3010
3011		default :
3012		    break loop36;
3013                }
3014            } while (true);
3015            } finally {dbg.exitSubRule(36);}
3016
3017            dbg.location(491,9);
3018            match(input,RBRACE,FOLLOW_RBRACE_in_interfaceBody1540); if (state.failed) return ;
3019
3020            }
3021
3022        }
3023        catch (RecognitionException re) {
3024            reportError(re);
3025            recover(input,re);
3026        }
3027        finally {
3028            if ( state.backtracking>0 ) { memoize(input, 23, interfaceBody_StartIndex); }
3029        }
3030        dbg.location(492, 5);
3031
3032        }
3033        finally {
3034            dbg.exitRule(getGrammarFileName(), "interfaceBody");
3035            decRuleLevel();
3036            if ( getRuleLevel()==0 ) {dbg.terminate();}
3037        }
3038
3039        return ;
3040    }
3041    // $ANTLR end "interfaceBody"
3042
3043
3044    // $ANTLR start "classBodyDeclaration"
3045    // src/com/google/doclava/parser/Java.g:494:1: classBodyDeclaration : ( ';' | ( 'static' )? block | memberDecl );
3046    public final void classBodyDeclaration() throws RecognitionException {
3047        int classBodyDeclaration_StartIndex = input.index();
3048        try { dbg.enterRule(getGrammarFileName(), "classBodyDeclaration");
3049        if ( getRuleLevel()==0 ) {dbg.commence();}
3050        incRuleLevel();
3051        dbg.location(494, 1);
3052
3053        try {
3054            if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return ; }
3055            // src/com/google/doclava/parser/Java.g:495:5: ( ';' | ( 'static' )? block | memberDecl )
3056            int alt38=3;
3057            try { dbg.enterDecision(38, decisionCanBacktrack[38]);
3058
3059            switch ( input.LA(1) ) {
3060            case SEMI:
3061                {
3062                alt38=1;
3063                }
3064                break;
3065            case STATIC:
3066                {
3067                int LA38_2 = input.LA(2);
3068
3069                if ( (LA38_2==LBRACE) ) {
3070                    alt38=2;
3071                }
3072                else if ( (LA38_2==IDENTIFIER||LA38_2==ABSTRACT||LA38_2==BOOLEAN||LA38_2==BYTE||(LA38_2>=CHAR && LA38_2<=CLASS)||LA38_2==DOUBLE||LA38_2==ENUM||LA38_2==FINAL||LA38_2==FLOAT||(LA38_2>=INT && LA38_2<=NATIVE)||(LA38_2>=PRIVATE && LA38_2<=PUBLIC)||(LA38_2>=SHORT && LA38_2<=STRICTFP)||LA38_2==SYNCHRONIZED||LA38_2==TRANSIENT||(LA38_2>=VOID && LA38_2<=VOLATILE)||LA38_2==MONKEYS_AT||LA38_2==LT) ) {
3073                    alt38=3;
3074                }
3075                else {
3076                    if (state.backtracking>0) {state.failed=true; return ;}
3077                    NoViableAltException nvae =
3078                        new NoViableAltException("", 38, 2, input);
3079
3080                    dbg.recognitionException(nvae);
3081                    throw nvae;
3082                }
3083                }
3084                break;
3085            case LBRACE:
3086                {
3087                alt38=2;
3088                }
3089                break;
3090            case IDENTIFIER:
3091            case ABSTRACT:
3092            case BOOLEAN:
3093            case BYTE:
3094            case CHAR:
3095            case CLASS:
3096            case DOUBLE:
3097            case ENUM:
3098            case FINAL:
3099            case FLOAT:
3100            case INT:
3101            case INTERFACE:
3102            case LONG:
3103            case NATIVE:
3104            case PRIVATE:
3105            case PROTECTED:
3106            case PUBLIC:
3107            case SHORT:
3108            case STRICTFP:
3109            case SYNCHRONIZED:
3110            case TRANSIENT:
3111            case VOID:
3112            case VOLATILE:
3113            case MONKEYS_AT:
3114            case LT:
3115                {
3116                alt38=3;
3117                }
3118                break;
3119            default:
3120                if (state.backtracking>0) {state.failed=true; return ;}
3121                NoViableAltException nvae =
3122                    new NoViableAltException("", 38, 0, input);
3123
3124                dbg.recognitionException(nvae);
3125                throw nvae;
3126            }
3127
3128            } finally {dbg.exitDecision(38);}
3129
3130            switch (alt38) {
3131                case 1 :
3132                    dbg.enterAlt(1);
3133
3134                    // src/com/google/doclava/parser/Java.g:495:9: ';'
3135                    {
3136                    dbg.location(495,9);
3137                    match(input,SEMI,FOLLOW_SEMI_in_classBodyDeclaration1559); if (state.failed) return ;
3138
3139                    }
3140                    break;
3141                case 2 :
3142                    dbg.enterAlt(2);
3143
3144                    // src/com/google/doclava/parser/Java.g:496:9: ( 'static' )? block
3145                    {
3146                    dbg.location(496,9);
3147                    // src/com/google/doclava/parser/Java.g:496:9: ( 'static' )?
3148                    int alt37=2;
3149                    try { dbg.enterSubRule(37);
3150                    try { dbg.enterDecision(37, decisionCanBacktrack[37]);
3151
3152                    int LA37_0 = input.LA(1);
3153
3154                    if ( (LA37_0==STATIC) ) {
3155                        alt37=1;
3156                    }
3157                    } finally {dbg.exitDecision(37);}
3158
3159                    switch (alt37) {
3160                        case 1 :
3161                            dbg.enterAlt(1);
3162
3163                            // src/com/google/doclava/parser/Java.g:496:10: 'static'
3164                            {
3165                            dbg.location(496,10);
3166                            match(input,STATIC,FOLLOW_STATIC_in_classBodyDeclaration1570); if (state.failed) return ;
3167
3168                            }
3169                            break;
3170
3171                    }
3172                    } finally {dbg.exitSubRule(37);}
3173
3174                    dbg.location(498,9);
3175                    pushFollow(FOLLOW_block_in_classBodyDeclaration1591);
3176                    block();
3177
3178                    state._fsp--;
3179                    if (state.failed) return ;
3180
3181                    }
3182                    break;
3183                case 3 :
3184                    dbg.enterAlt(3);
3185
3186                    // src/com/google/doclava/parser/Java.g:499:9: memberDecl
3187                    {
3188                    dbg.location(499,9);
3189                    pushFollow(FOLLOW_memberDecl_in_classBodyDeclaration1601);
3190                    memberDecl();
3191
3192                    state._fsp--;
3193                    if (state.failed) return ;
3194
3195                    }
3196                    break;
3197
3198            }
3199        }
3200        catch (RecognitionException re) {
3201            reportError(re);
3202            recover(input,re);
3203        }
3204        finally {
3205            if ( state.backtracking>0 ) { memoize(input, 24, classBodyDeclaration_StartIndex); }
3206        }
3207        dbg.location(500, 5);
3208
3209        }
3210        finally {
3211            dbg.exitRule(getGrammarFileName(), "classBodyDeclaration");
3212            decRuleLevel();
3213            if ( getRuleLevel()==0 ) {dbg.terminate();}
3214        }
3215
3216        return ;
3217    }
3218    // $ANTLR end "classBodyDeclaration"
3219
3220
3221    // $ANTLR start "memberDecl"
3222    // src/com/google/doclava/parser/Java.g:502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );
3223    public final void memberDecl() throws RecognitionException {
3224        int memberDecl_StartIndex = input.index();
3225        try { dbg.enterRule(getGrammarFileName(), "memberDecl");
3226        if ( getRuleLevel()==0 ) {dbg.commence();}
3227        incRuleLevel();
3228        dbg.location(502, 1);
3229
3230        try {
3231            if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return ; }
3232            // src/com/google/doclava/parser/Java.g:503:5: ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration )
3233            int alt39=4;
3234            try { dbg.enterDecision(39, decisionCanBacktrack[39]);
3235
3236            try {
3237                isCyclicDecision = true;
3238                alt39 = dfa39.predict(input);
3239            }
3240            catch (NoViableAltException nvae) {
3241                dbg.recognitionException(nvae);
3242                throw nvae;
3243            }
3244            } finally {dbg.exitDecision(39);}
3245
3246            switch (alt39) {
3247                case 1 :
3248                    dbg.enterAlt(1);
3249
3250                    // src/com/google/doclava/parser/Java.g:503:10: fieldDeclaration
3251                    {
3252                    dbg.location(503,10);
3253                    pushFollow(FOLLOW_fieldDeclaration_in_memberDecl1621);
3254                    fieldDeclaration();
3255
3256                    state._fsp--;
3257                    if (state.failed) return ;
3258
3259                    }
3260                    break;
3261                case 2 :
3262                    dbg.enterAlt(2);
3263
3264                    // src/com/google/doclava/parser/Java.g:504:10: methodDeclaration
3265                    {
3266                    dbg.location(504,10);
3267                    pushFollow(FOLLOW_methodDeclaration_in_memberDecl1632);
3268                    methodDeclaration();
3269
3270                    state._fsp--;
3271                    if (state.failed) return ;
3272
3273                    }
3274                    break;
3275                case 3 :
3276                    dbg.enterAlt(3);
3277
3278                    // src/com/google/doclava/parser/Java.g:505:10: classDeclaration
3279                    {
3280                    dbg.location(505,10);
3281                    pushFollow(FOLLOW_classDeclaration_in_memberDecl1643);
3282                    classDeclaration();
3283
3284                    state._fsp--;
3285                    if (state.failed) return ;
3286
3287                    }
3288                    break;
3289                case 4 :
3290                    dbg.enterAlt(4);
3291
3292                    // src/com/google/doclava/parser/Java.g:506:10: interfaceDeclaration
3293                    {
3294                    dbg.location(506,10);
3295                    pushFollow(FOLLOW_interfaceDeclaration_in_memberDecl1654);
3296                    interfaceDeclaration();
3297
3298                    state._fsp--;
3299                    if (state.failed) return ;
3300
3301                    }
3302                    break;
3303
3304            }
3305        }
3306        catch (RecognitionException re) {
3307            reportError(re);
3308            recover(input,re);
3309        }
3310        finally {
3311            if ( state.backtracking>0 ) { memoize(input, 25, memberDecl_StartIndex); }
3312        }
3313        dbg.location(507, 5);
3314
3315        }
3316        finally {
3317            dbg.exitRule(getGrammarFileName(), "memberDecl");
3318            decRuleLevel();
3319            if ( getRuleLevel()==0 ) {dbg.terminate();}
3320        }
3321
3322        return ;
3323    }
3324    // $ANTLR end "memberDecl"
3325
3326
3327    // $ANTLR start "methodDeclaration"
3328    // src/com/google/doclava/parser/Java.g:510:1: methodDeclaration : ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) );
3329    public final void methodDeclaration() throws RecognitionException {
3330        int methodDeclaration_StartIndex = input.index();
3331        try { dbg.enterRule(getGrammarFileName(), "methodDeclaration");
3332        if ( getRuleLevel()==0 ) {dbg.commence();}
3333        incRuleLevel();
3334        dbg.location(510, 1);
3335
3336        try {
3337            if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return ; }
3338            // src/com/google/doclava/parser/Java.g:511:5: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) )
3339            int alt49=2;
3340            try { dbg.enterDecision(49, decisionCanBacktrack[49]);
3341
3342            try {
3343                isCyclicDecision = true;
3344                alt49 = dfa49.predict(input);
3345            }
3346            catch (NoViableAltException nvae) {
3347                dbg.recognitionException(nvae);
3348                throw nvae;
3349            }
3350            } finally {dbg.exitDecision(49);}
3351
3352            switch (alt49) {
3353                case 1 :
3354                    dbg.enterAlt(1);
3355
3356                    // src/com/google/doclava/parser/Java.g:513:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}'
3357                    {
3358                    dbg.location(513,10);
3359                    pushFollow(FOLLOW_modifiers_in_methodDeclaration1691);
3360                    modifiers();
3361
3362                    state._fsp--;
3363                    if (state.failed) return ;
3364                    dbg.location(514,9);
3365                    // src/com/google/doclava/parser/Java.g:514:9: ( typeParameters )?
3366                    int alt40=2;
3367                    try { dbg.enterSubRule(40);
3368                    try { dbg.enterDecision(40, decisionCanBacktrack[40]);
3369
3370                    int LA40_0 = input.LA(1);
3371
3372                    if ( (LA40_0==LT) ) {
3373                        alt40=1;
3374                    }
3375                    } finally {dbg.exitDecision(40);}
3376
3377                    switch (alt40) {
3378                        case 1 :
3379                            dbg.enterAlt(1);
3380
3381                            // src/com/google/doclava/parser/Java.g:514:10: typeParameters
3382                            {
3383                            dbg.location(514,10);
3384                            pushFollow(FOLLOW_typeParameters_in_methodDeclaration1702);
3385                            typeParameters();
3386
3387                            state._fsp--;
3388                            if (state.failed) return ;
3389
3390                            }
3391                            break;
3392
3393                    }
3394                    } finally {dbg.exitSubRule(40);}
3395
3396                    dbg.location(516,9);
3397                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration1723); if (state.failed) return ;
3398                    dbg.location(517,9);
3399                    pushFollow(FOLLOW_formalParameters_in_methodDeclaration1733);
3400                    formalParameters();
3401
3402                    state._fsp--;
3403                    if (state.failed) return ;
3404                    dbg.location(518,9);
3405                    // src/com/google/doclava/parser/Java.g:518:9: ( 'throws' qualifiedNameList )?
3406                    int alt41=2;
3407                    try { dbg.enterSubRule(41);
3408                    try { dbg.enterDecision(41, decisionCanBacktrack[41]);
3409
3410                    int LA41_0 = input.LA(1);
3411
3412                    if ( (LA41_0==THROWS) ) {
3413                        alt41=1;
3414                    }
3415                    } finally {dbg.exitDecision(41);}
3416
3417                    switch (alt41) {
3418                        case 1 :
3419                            dbg.enterAlt(1);
3420
3421                            // src/com/google/doclava/parser/Java.g:518:10: 'throws' qualifiedNameList
3422                            {
3423                            dbg.location(518,10);
3424                            match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration1744); if (state.failed) return ;
3425                            dbg.location(518,19);
3426                            pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration1746);
3427                            qualifiedNameList();
3428
3429                            state._fsp--;
3430                            if (state.failed) return ;
3431
3432                            }
3433                            break;
3434
3435                    }
3436                    } finally {dbg.exitSubRule(41);}
3437
3438                    dbg.location(520,9);
3439                    match(input,LBRACE,FOLLOW_LBRACE_in_methodDeclaration1767); if (state.failed) return ;
3440                    dbg.location(521,9);
3441                    // src/com/google/doclava/parser/Java.g:521:9: ( explicitConstructorInvocation )?
3442                    int alt42=2;
3443                    try { dbg.enterSubRule(42);
3444                    try { dbg.enterDecision(42, decisionCanBacktrack[42]);
3445
3446                    try {
3447                        isCyclicDecision = true;
3448                        alt42 = dfa42.predict(input);
3449                    }
3450                    catch (NoViableAltException nvae) {
3451                        dbg.recognitionException(nvae);
3452                        throw nvae;
3453                    }
3454                    } finally {dbg.exitDecision(42);}
3455
3456                    switch (alt42) {
3457                        case 1 :
3458                            dbg.enterAlt(1);
3459
3460                            // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation
3461                            {
3462                            dbg.location(521,10);
3463                            pushFollow(FOLLOW_explicitConstructorInvocation_in_methodDeclaration1778);
3464                            explicitConstructorInvocation();
3465
3466                            state._fsp--;
3467                            if (state.failed) return ;
3468
3469                            }
3470                            break;
3471
3472                    }
3473                    } finally {dbg.exitSubRule(42);}
3474
3475                    dbg.location(523,9);
3476                    // src/com/google/doclava/parser/Java.g:523:9: ( blockStatement )*
3477                    try { dbg.enterSubRule(43);
3478
3479                    loop43:
3480                    do {
3481                        int alt43=2;
3482                        try { dbg.enterDecision(43, decisionCanBacktrack[43]);
3483
3484                        int LA43_0 = input.LA(1);
3485
3486                        if ( ((LA43_0>=IDENTIFIER && LA43_0<=NULL)||(LA43_0>=ABSTRACT && LA43_0<=BYTE)||(LA43_0>=CHAR && LA43_0<=CLASS)||LA43_0==CONTINUE||(LA43_0>=DO && LA43_0<=DOUBLE)||LA43_0==ENUM||LA43_0==FINAL||(LA43_0>=FLOAT && LA43_0<=FOR)||LA43_0==IF||(LA43_0>=INT && LA43_0<=NEW)||(LA43_0>=PRIVATE && LA43_0<=THROW)||(LA43_0>=TRANSIENT && LA43_0<=LPAREN)||LA43_0==LBRACE||LA43_0==SEMI||(LA43_0>=BANG && LA43_0<=TILDE)||(LA43_0>=PLUSPLUS && LA43_0<=SUB)||LA43_0==MONKEYS_AT||LA43_0==LT) ) {
3487                            alt43=1;
3488                        }
3489
3490
3491                        } finally {dbg.exitDecision(43);}
3492
3493                        switch (alt43) {
3494			case 1 :
3495			    dbg.enterAlt(1);
3496
3497			    // src/com/google/doclava/parser/Java.g:523:10: blockStatement
3498			    {
3499			    dbg.location(523,10);
3500			    pushFollow(FOLLOW_blockStatement_in_methodDeclaration1800);
3501			    blockStatement();
3502
3503			    state._fsp--;
3504			    if (state.failed) return ;
3505
3506			    }
3507			    break;
3508
3509			default :
3510			    break loop43;
3511                        }
3512                    } while (true);
3513                    } finally {dbg.exitSubRule(43);}
3514
3515                    dbg.location(525,9);
3516                    match(input,RBRACE,FOLLOW_RBRACE_in_methodDeclaration1821); if (state.failed) return ;
3517
3518                    }
3519                    break;
3520                case 2 :
3521                    dbg.enterAlt(2);
3522
3523                    // src/com/google/doclava/parser/Java.g:526:9: modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' )
3524                    {
3525                    dbg.location(526,9);
3526                    pushFollow(FOLLOW_modifiers_in_methodDeclaration1831);
3527                    modifiers();
3528
3529                    state._fsp--;
3530                    if (state.failed) return ;
3531                    dbg.location(527,9);
3532                    // src/com/google/doclava/parser/Java.g:527:9: ( typeParameters )?
3533                    int alt44=2;
3534                    try { dbg.enterSubRule(44);
3535                    try { dbg.enterDecision(44, decisionCanBacktrack[44]);
3536
3537                    int LA44_0 = input.LA(1);
3538
3539                    if ( (LA44_0==LT) ) {
3540                        alt44=1;
3541                    }
3542                    } finally {dbg.exitDecision(44);}
3543
3544                    switch (alt44) {
3545                        case 1 :
3546                            dbg.enterAlt(1);
3547
3548                            // src/com/google/doclava/parser/Java.g:527:10: typeParameters
3549                            {
3550                            dbg.location(527,10);
3551                            pushFollow(FOLLOW_typeParameters_in_methodDeclaration1842);
3552                            typeParameters();
3553
3554                            state._fsp--;
3555                            if (state.failed) return ;
3556
3557                            }
3558                            break;
3559
3560                    }
3561                    } finally {dbg.exitSubRule(44);}
3562
3563                    dbg.location(529,9);
3564                    // src/com/google/doclava/parser/Java.g:529:9: ( type | 'void' )
3565                    int alt45=2;
3566                    try { dbg.enterSubRule(45);
3567                    try { dbg.enterDecision(45, decisionCanBacktrack[45]);
3568
3569                    int LA45_0 = input.LA(1);
3570
3571                    if ( (LA45_0==IDENTIFIER||LA45_0==BOOLEAN||LA45_0==BYTE||LA45_0==CHAR||LA45_0==DOUBLE||LA45_0==FLOAT||LA45_0==INT||LA45_0==LONG||LA45_0==SHORT) ) {
3572                        alt45=1;
3573                    }
3574                    else if ( (LA45_0==VOID) ) {
3575                        alt45=2;
3576                    }
3577                    else {
3578                        if (state.backtracking>0) {state.failed=true; return ;}
3579                        NoViableAltException nvae =
3580                            new NoViableAltException("", 45, 0, input);
3581
3582                        dbg.recognitionException(nvae);
3583                        throw nvae;
3584                    }
3585                    } finally {dbg.exitDecision(45);}
3586
3587                    switch (alt45) {
3588                        case 1 :
3589                            dbg.enterAlt(1);
3590
3591                            // src/com/google/doclava/parser/Java.g:529:10: type
3592                            {
3593                            dbg.location(529,10);
3594                            pushFollow(FOLLOW_type_in_methodDeclaration1864);
3595                            type();
3596
3597                            state._fsp--;
3598                            if (state.failed) return ;
3599
3600                            }
3601                            break;
3602                        case 2 :
3603                            dbg.enterAlt(2);
3604
3605                            // src/com/google/doclava/parser/Java.g:530:13: 'void'
3606                            {
3607                            dbg.location(530,13);
3608                            match(input,VOID,FOLLOW_VOID_in_methodDeclaration1878); if (state.failed) return ;
3609
3610                            }
3611                            break;
3612
3613                    }
3614                    } finally {dbg.exitSubRule(45);}
3615
3616                    dbg.location(532,9);
3617                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration1898); if (state.failed) return ;
3618                    dbg.location(533,9);
3619                    pushFollow(FOLLOW_formalParameters_in_methodDeclaration1908);
3620                    formalParameters();
3621
3622                    state._fsp--;
3623                    if (state.failed) return ;
3624                    dbg.location(534,9);
3625                    // src/com/google/doclava/parser/Java.g:534:9: ( '[' ']' )*
3626                    try { dbg.enterSubRule(46);
3627
3628                    loop46:
3629                    do {
3630                        int alt46=2;
3631                        try { dbg.enterDecision(46, decisionCanBacktrack[46]);
3632
3633                        int LA46_0 = input.LA(1);
3634
3635                        if ( (LA46_0==LBRACKET) ) {
3636                            alt46=1;
3637                        }
3638
3639
3640                        } finally {dbg.exitDecision(46);}
3641
3642                        switch (alt46) {
3643			case 1 :
3644			    dbg.enterAlt(1);
3645
3646			    // src/com/google/doclava/parser/Java.g:534:10: '[' ']'
3647			    {
3648			    dbg.location(534,10);
3649			    match(input,LBRACKET,FOLLOW_LBRACKET_in_methodDeclaration1919); if (state.failed) return ;
3650			    dbg.location(534,14);
3651			    match(input,RBRACKET,FOLLOW_RBRACKET_in_methodDeclaration1921); if (state.failed) return ;
3652
3653			    }
3654			    break;
3655
3656			default :
3657			    break loop46;
3658                        }
3659                    } while (true);
3660                    } finally {dbg.exitSubRule(46);}
3661
3662                    dbg.location(536,9);
3663                    // src/com/google/doclava/parser/Java.g:536:9: ( 'throws' qualifiedNameList )?
3664                    int alt47=2;
3665                    try { dbg.enterSubRule(47);
3666                    try { dbg.enterDecision(47, decisionCanBacktrack[47]);
3667
3668                    int LA47_0 = input.LA(1);
3669
3670                    if ( (LA47_0==THROWS) ) {
3671                        alt47=1;
3672                    }
3673                    } finally {dbg.exitDecision(47);}
3674
3675                    switch (alt47) {
3676                        case 1 :
3677                            dbg.enterAlt(1);
3678
3679                            // src/com/google/doclava/parser/Java.g:536:10: 'throws' qualifiedNameList
3680                            {
3681                            dbg.location(536,10);
3682                            match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration1943); if (state.failed) return ;
3683                            dbg.location(536,19);
3684                            pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration1945);
3685                            qualifiedNameList();
3686
3687                            state._fsp--;
3688                            if (state.failed) return ;
3689
3690                            }
3691                            break;
3692
3693                    }
3694                    } finally {dbg.exitSubRule(47);}
3695
3696                    dbg.location(538,9);
3697                    // src/com/google/doclava/parser/Java.g:538:9: ( block | ';' )
3698                    int alt48=2;
3699                    try { dbg.enterSubRule(48);
3700                    try { dbg.enterDecision(48, decisionCanBacktrack[48]);
3701
3702                    int LA48_0 = input.LA(1);
3703
3704                    if ( (LA48_0==LBRACE) ) {
3705                        alt48=1;
3706                    }
3707                    else if ( (LA48_0==SEMI) ) {
3708                        alt48=2;
3709                    }
3710                    else {
3711                        if (state.backtracking>0) {state.failed=true; return ;}
3712                        NoViableAltException nvae =
3713                            new NoViableAltException("", 48, 0, input);
3714
3715                        dbg.recognitionException(nvae);
3716                        throw nvae;
3717                    }
3718                    } finally {dbg.exitDecision(48);}
3719
3720                    switch (alt48) {
3721                        case 1 :
3722                            dbg.enterAlt(1);
3723
3724                            // src/com/google/doclava/parser/Java.g:539:13: block
3725                            {
3726                            dbg.location(539,13);
3727                            pushFollow(FOLLOW_block_in_methodDeclaration1980);
3728                            block();
3729
3730                            state._fsp--;
3731                            if (state.failed) return ;
3732
3733                            }
3734                            break;
3735                        case 2 :
3736                            dbg.enterAlt(2);
3737
3738                            // src/com/google/doclava/parser/Java.g:540:13: ';'
3739                            {
3740                            dbg.location(540,13);
3741                            match(input,SEMI,FOLLOW_SEMI_in_methodDeclaration1994); if (state.failed) return ;
3742
3743                            }
3744                            break;
3745
3746                    }
3747                    } finally {dbg.exitSubRule(48);}
3748
3749
3750                    }
3751                    break;
3752
3753            }
3754        }
3755        catch (RecognitionException re) {
3756            reportError(re);
3757            recover(input,re);
3758        }
3759        finally {
3760            if ( state.backtracking>0 ) { memoize(input, 26, methodDeclaration_StartIndex); }
3761        }
3762        dbg.location(542, 5);
3763
3764        }
3765        finally {
3766            dbg.exitRule(getGrammarFileName(), "methodDeclaration");
3767            decRuleLevel();
3768            if ( getRuleLevel()==0 ) {dbg.terminate();}
3769        }
3770
3771        return ;
3772    }
3773    // $ANTLR end "methodDeclaration"
3774
3775
3776    // $ANTLR start "fieldDeclaration"
3777    // src/com/google/doclava/parser/Java.g:545:1: fieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ;
3778    public final void fieldDeclaration() throws RecognitionException {
3779        int fieldDeclaration_StartIndex = input.index();
3780        try { dbg.enterRule(getGrammarFileName(), "fieldDeclaration");
3781        if ( getRuleLevel()==0 ) {dbg.commence();}
3782        incRuleLevel();
3783        dbg.location(545, 1);
3784
3785        try {
3786            if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return ; }
3787            // src/com/google/doclava/parser/Java.g:546:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' )
3788            dbg.enterAlt(1);
3789
3790            // src/com/google/doclava/parser/Java.g:546:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';'
3791            {
3792            dbg.location(546,9);
3793            pushFollow(FOLLOW_modifiers_in_fieldDeclaration2024);
3794            modifiers();
3795
3796            state._fsp--;
3797            if (state.failed) return ;
3798            dbg.location(547,9);
3799            pushFollow(FOLLOW_type_in_fieldDeclaration2034);
3800            type();
3801
3802            state._fsp--;
3803            if (state.failed) return ;
3804            dbg.location(548,9);
3805            pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2044);
3806            variableDeclarator();
3807
3808            state._fsp--;
3809            if (state.failed) return ;
3810            dbg.location(549,9);
3811            // src/com/google/doclava/parser/Java.g:549:9: ( ',' variableDeclarator )*
3812            try { dbg.enterSubRule(50);
3813
3814            loop50:
3815            do {
3816                int alt50=2;
3817                try { dbg.enterDecision(50, decisionCanBacktrack[50]);
3818
3819                int LA50_0 = input.LA(1);
3820
3821                if ( (LA50_0==COMMA) ) {
3822                    alt50=1;
3823                }
3824
3825
3826                } finally {dbg.exitDecision(50);}
3827
3828                switch (alt50) {
3829		case 1 :
3830		    dbg.enterAlt(1);
3831
3832		    // src/com/google/doclava/parser/Java.g:549:10: ',' variableDeclarator
3833		    {
3834		    dbg.location(549,10);
3835		    match(input,COMMA,FOLLOW_COMMA_in_fieldDeclaration2055); if (state.failed) return ;
3836		    dbg.location(549,14);
3837		    pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2057);
3838		    variableDeclarator();
3839
3840		    state._fsp--;
3841		    if (state.failed) return ;
3842
3843		    }
3844		    break;
3845
3846		default :
3847		    break loop50;
3848                }
3849            } while (true);
3850            } finally {dbg.exitSubRule(50);}
3851
3852            dbg.location(551,9);
3853            match(input,SEMI,FOLLOW_SEMI_in_fieldDeclaration2078); if (state.failed) return ;
3854
3855            }
3856
3857        }
3858        catch (RecognitionException re) {
3859            reportError(re);
3860            recover(input,re);
3861        }
3862        finally {
3863            if ( state.backtracking>0 ) { memoize(input, 27, fieldDeclaration_StartIndex); }
3864        }
3865        dbg.location(552, 5);
3866
3867        }
3868        finally {
3869            dbg.exitRule(getGrammarFileName(), "fieldDeclaration");
3870            decRuleLevel();
3871            if ( getRuleLevel()==0 ) {dbg.terminate();}
3872        }
3873
3874        return ;
3875    }
3876    // $ANTLR end "fieldDeclaration"
3877
3878
3879    // $ANTLR start "variableDeclarator"
3880    // src/com/google/doclava/parser/Java.g:554:1: variableDeclarator : IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? ;
3881    public final void variableDeclarator() throws RecognitionException {
3882        int variableDeclarator_StartIndex = input.index();
3883        try { dbg.enterRule(getGrammarFileName(), "variableDeclarator");
3884        if ( getRuleLevel()==0 ) {dbg.commence();}
3885        incRuleLevel();
3886        dbg.location(554, 1);
3887
3888        try {
3889            if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return ; }
3890            // src/com/google/doclava/parser/Java.g:555:5: ( IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? )
3891            dbg.enterAlt(1);
3892
3893            // src/com/google/doclava/parser/Java.g:555:9: IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )?
3894            {
3895            dbg.location(555,9);
3896            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variableDeclarator2097); if (state.failed) return ;
3897            dbg.location(556,9);
3898            // src/com/google/doclava/parser/Java.g:556:9: ( '[' ']' )*
3899            try { dbg.enterSubRule(51);
3900
3901            loop51:
3902            do {
3903                int alt51=2;
3904                try { dbg.enterDecision(51, decisionCanBacktrack[51]);
3905
3906                int LA51_0 = input.LA(1);
3907
3908                if ( (LA51_0==LBRACKET) ) {
3909                    alt51=1;
3910                }
3911
3912
3913                } finally {dbg.exitDecision(51);}
3914
3915                switch (alt51) {
3916		case 1 :
3917		    dbg.enterAlt(1);
3918
3919		    // src/com/google/doclava/parser/Java.g:556:10: '[' ']'
3920		    {
3921		    dbg.location(556,10);
3922		    match(input,LBRACKET,FOLLOW_LBRACKET_in_variableDeclarator2108); if (state.failed) return ;
3923		    dbg.location(556,14);
3924		    match(input,RBRACKET,FOLLOW_RBRACKET_in_variableDeclarator2110); if (state.failed) return ;
3925
3926		    }
3927		    break;
3928
3929		default :
3930		    break loop51;
3931                }
3932            } while (true);
3933            } finally {dbg.exitSubRule(51);}
3934
3935            dbg.location(558,9);
3936            // src/com/google/doclava/parser/Java.g:558:9: ( '=' variableInitializer )?
3937            int alt52=2;
3938            try { dbg.enterSubRule(52);
3939            try { dbg.enterDecision(52, decisionCanBacktrack[52]);
3940
3941            int LA52_0 = input.LA(1);
3942
3943            if ( (LA52_0==EQ) ) {
3944                alt52=1;
3945            }
3946            } finally {dbg.exitDecision(52);}
3947
3948            switch (alt52) {
3949                case 1 :
3950                    dbg.enterAlt(1);
3951
3952                    // src/com/google/doclava/parser/Java.g:558:10: '=' variableInitializer
3953                    {
3954                    dbg.location(558,10);
3955                    match(input,EQ,FOLLOW_EQ_in_variableDeclarator2132); if (state.failed) return ;
3956                    dbg.location(558,14);
3957                    pushFollow(FOLLOW_variableInitializer_in_variableDeclarator2134);
3958                    variableInitializer();
3959
3960                    state._fsp--;
3961                    if (state.failed) return ;
3962
3963                    }
3964                    break;
3965
3966            }
3967            } finally {dbg.exitSubRule(52);}
3968
3969
3970            }
3971
3972        }
3973        catch (RecognitionException re) {
3974            reportError(re);
3975            recover(input,re);
3976        }
3977        finally {
3978            if ( state.backtracking>0 ) { memoize(input, 28, variableDeclarator_StartIndex); }
3979        }
3980        dbg.location(560, 5);
3981
3982        }
3983        finally {
3984            dbg.exitRule(getGrammarFileName(), "variableDeclarator");
3985            decRuleLevel();
3986            if ( getRuleLevel()==0 ) {dbg.terminate();}
3987        }
3988
3989        return ;
3990    }
3991    // $ANTLR end "variableDeclarator"
3992
3993
3994    // $ANTLR start "interfaceBodyDeclaration"
3995    // src/com/google/doclava/parser/Java.g:562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' );
3996    public final void interfaceBodyDeclaration() throws RecognitionException {
3997        int interfaceBodyDeclaration_StartIndex = input.index();
3998        try { dbg.enterRule(getGrammarFileName(), "interfaceBodyDeclaration");
3999        if ( getRuleLevel()==0 ) {dbg.commence();}
4000        incRuleLevel();
4001        dbg.location(562, 1);
4002
4003        try {
4004            if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return ; }
4005            // src/com/google/doclava/parser/Java.g:566:5: ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' )
4006            int alt53=5;
4007            try { dbg.enterDecision(53, decisionCanBacktrack[53]);
4008
4009            try {
4010                isCyclicDecision = true;
4011                alt53 = dfa53.predict(input);
4012            }
4013            catch (NoViableAltException nvae) {
4014                dbg.recognitionException(nvae);
4015                throw nvae;
4016            }
4017            } finally {dbg.exitDecision(53);}
4018
4019            switch (alt53) {
4020                case 1 :
4021                    dbg.enterAlt(1);
4022
4023                    // src/com/google/doclava/parser/Java.g:567:9: interfaceFieldDeclaration
4024                    {
4025                    dbg.location(567,9);
4026                    pushFollow(FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration2172);
4027                    interfaceFieldDeclaration();
4028
4029                    state._fsp--;
4030                    if (state.failed) return ;
4031
4032                    }
4033                    break;
4034                case 2 :
4035                    dbg.enterAlt(2);
4036
4037                    // src/com/google/doclava/parser/Java.g:568:9: interfaceMethodDeclaration
4038                    {
4039                    dbg.location(568,9);
4040                    pushFollow(FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration2182);
4041                    interfaceMethodDeclaration();
4042
4043                    state._fsp--;
4044                    if (state.failed) return ;
4045
4046                    }
4047                    break;
4048                case 3 :
4049                    dbg.enterAlt(3);
4050
4051                    // src/com/google/doclava/parser/Java.g:569:9: interfaceDeclaration
4052                    {
4053                    dbg.location(569,9);
4054                    pushFollow(FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration2192);
4055                    interfaceDeclaration();
4056
4057                    state._fsp--;
4058                    if (state.failed) return ;
4059
4060                    }
4061                    break;
4062                case 4 :
4063                    dbg.enterAlt(4);
4064
4065                    // src/com/google/doclava/parser/Java.g:570:9: classDeclaration
4066                    {
4067                    dbg.location(570,9);
4068                    pushFollow(FOLLOW_classDeclaration_in_interfaceBodyDeclaration2202);
4069                    classDeclaration();
4070
4071                    state._fsp--;
4072                    if (state.failed) return ;
4073
4074                    }
4075                    break;
4076                case 5 :
4077                    dbg.enterAlt(5);
4078
4079                    // src/com/google/doclava/parser/Java.g:571:9: ';'
4080                    {
4081                    dbg.location(571,9);
4082                    match(input,SEMI,FOLLOW_SEMI_in_interfaceBodyDeclaration2212); if (state.failed) return ;
4083
4084                    }
4085                    break;
4086
4087            }
4088        }
4089        catch (RecognitionException re) {
4090            reportError(re);
4091            recover(input,re);
4092        }
4093        finally {
4094            if ( state.backtracking>0 ) { memoize(input, 29, interfaceBodyDeclaration_StartIndex); }
4095        }
4096        dbg.location(572, 5);
4097
4098        }
4099        finally {
4100            dbg.exitRule(getGrammarFileName(), "interfaceBodyDeclaration");
4101            decRuleLevel();
4102            if ( getRuleLevel()==0 ) {dbg.terminate();}
4103        }
4104
4105        return ;
4106    }
4107    // $ANTLR end "interfaceBodyDeclaration"
4108
4109
4110    // $ANTLR start "interfaceMethodDeclaration"
4111    // src/com/google/doclava/parser/Java.g:574:1: interfaceMethodDeclaration : modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' ;
4112    public final void interfaceMethodDeclaration() throws RecognitionException {
4113        int interfaceMethodDeclaration_StartIndex = input.index();
4114        try { dbg.enterRule(getGrammarFileName(), "interfaceMethodDeclaration");
4115        if ( getRuleLevel()==0 ) {dbg.commence();}
4116        incRuleLevel();
4117        dbg.location(574, 1);
4118
4119        try {
4120            if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return ; }
4121            // src/com/google/doclava/parser/Java.g:575:5: ( modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' )
4122            dbg.enterAlt(1);
4123
4124            // src/com/google/doclava/parser/Java.g:575:9: modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';'
4125            {
4126            dbg.location(575,9);
4127            pushFollow(FOLLOW_modifiers_in_interfaceMethodDeclaration2231);
4128            modifiers();
4129
4130            state._fsp--;
4131            if (state.failed) return ;
4132            dbg.location(576,9);
4133            // src/com/google/doclava/parser/Java.g:576:9: ( typeParameters )?
4134            int alt54=2;
4135            try { dbg.enterSubRule(54);
4136            try { dbg.enterDecision(54, decisionCanBacktrack[54]);
4137
4138            int LA54_0 = input.LA(1);
4139
4140            if ( (LA54_0==LT) ) {
4141                alt54=1;
4142            }
4143            } finally {dbg.exitDecision(54);}
4144
4145            switch (alt54) {
4146                case 1 :
4147                    dbg.enterAlt(1);
4148
4149                    // src/com/google/doclava/parser/Java.g:576:10: typeParameters
4150                    {
4151                    dbg.location(576,10);
4152                    pushFollow(FOLLOW_typeParameters_in_interfaceMethodDeclaration2242);
4153                    typeParameters();
4154
4155                    state._fsp--;
4156                    if (state.failed) return ;
4157
4158                    }
4159                    break;
4160
4161            }
4162            } finally {dbg.exitSubRule(54);}
4163
4164            dbg.location(578,9);
4165            // src/com/google/doclava/parser/Java.g:578:9: ( type | 'void' )
4166            int alt55=2;
4167            try { dbg.enterSubRule(55);
4168            try { dbg.enterDecision(55, decisionCanBacktrack[55]);
4169
4170            int LA55_0 = input.LA(1);
4171
4172            if ( (LA55_0==IDENTIFIER||LA55_0==BOOLEAN||LA55_0==BYTE||LA55_0==CHAR||LA55_0==DOUBLE||LA55_0==FLOAT||LA55_0==INT||LA55_0==LONG||LA55_0==SHORT) ) {
4173                alt55=1;
4174            }
4175            else if ( (LA55_0==VOID) ) {
4176                alt55=2;
4177            }
4178            else {
4179                if (state.backtracking>0) {state.failed=true; return ;}
4180                NoViableAltException nvae =
4181                    new NoViableAltException("", 55, 0, input);
4182
4183                dbg.recognitionException(nvae);
4184                throw nvae;
4185            }
4186            } finally {dbg.exitDecision(55);}
4187
4188            switch (alt55) {
4189                case 1 :
4190                    dbg.enterAlt(1);
4191
4192                    // src/com/google/doclava/parser/Java.g:578:10: type
4193                    {
4194                    dbg.location(578,10);
4195                    pushFollow(FOLLOW_type_in_interfaceMethodDeclaration2264);
4196                    type();
4197
4198                    state._fsp--;
4199                    if (state.failed) return ;
4200
4201                    }
4202                    break;
4203                case 2 :
4204                    dbg.enterAlt(2);
4205
4206                    // src/com/google/doclava/parser/Java.g:579:10: 'void'
4207                    {
4208                    dbg.location(579,10);
4209                    match(input,VOID,FOLLOW_VOID_in_interfaceMethodDeclaration2275); if (state.failed) return ;
4210
4211                    }
4212                    break;
4213
4214            }
4215            } finally {dbg.exitSubRule(55);}
4216
4217            dbg.location(581,9);
4218            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration2295); if (state.failed) return ;
4219            dbg.location(582,9);
4220            pushFollow(FOLLOW_formalParameters_in_interfaceMethodDeclaration2305);
4221            formalParameters();
4222
4223            state._fsp--;
4224            if (state.failed) return ;
4225            dbg.location(583,9);
4226            // src/com/google/doclava/parser/Java.g:583:9: ( '[' ']' )*
4227            try { dbg.enterSubRule(56);
4228
4229            loop56:
4230            do {
4231                int alt56=2;
4232                try { dbg.enterDecision(56, decisionCanBacktrack[56]);
4233
4234                int LA56_0 = input.LA(1);
4235
4236                if ( (LA56_0==LBRACKET) ) {
4237                    alt56=1;
4238                }
4239
4240
4241                } finally {dbg.exitDecision(56);}
4242
4243                switch (alt56) {
4244		case 1 :
4245		    dbg.enterAlt(1);
4246
4247		    // src/com/google/doclava/parser/Java.g:583:10: '[' ']'
4248		    {
4249		    dbg.location(583,10);
4250		    match(input,LBRACKET,FOLLOW_LBRACKET_in_interfaceMethodDeclaration2316); if (state.failed) return ;
4251		    dbg.location(583,14);
4252		    match(input,RBRACKET,FOLLOW_RBRACKET_in_interfaceMethodDeclaration2318); if (state.failed) return ;
4253
4254		    }
4255		    break;
4256
4257		default :
4258		    break loop56;
4259                }
4260            } while (true);
4261            } finally {dbg.exitSubRule(56);}
4262
4263            dbg.location(585,9);
4264            // src/com/google/doclava/parser/Java.g:585:9: ( 'throws' qualifiedNameList )?
4265            int alt57=2;
4266            try { dbg.enterSubRule(57);
4267            try { dbg.enterDecision(57, decisionCanBacktrack[57]);
4268
4269            int LA57_0 = input.LA(1);
4270
4271            if ( (LA57_0==THROWS) ) {
4272                alt57=1;
4273            }
4274            } finally {dbg.exitDecision(57);}
4275
4276            switch (alt57) {
4277                case 1 :
4278                    dbg.enterAlt(1);
4279
4280                    // src/com/google/doclava/parser/Java.g:585:10: 'throws' qualifiedNameList
4281                    {
4282                    dbg.location(585,10);
4283                    match(input,THROWS,FOLLOW_THROWS_in_interfaceMethodDeclaration2340); if (state.failed) return ;
4284                    dbg.location(585,19);
4285                    pushFollow(FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration2342);
4286                    qualifiedNameList();
4287
4288                    state._fsp--;
4289                    if (state.failed) return ;
4290
4291                    }
4292                    break;
4293
4294            }
4295            } finally {dbg.exitSubRule(57);}
4296
4297            dbg.location(586,12);
4298            match(input,SEMI,FOLLOW_SEMI_in_interfaceMethodDeclaration2355); if (state.failed) return ;
4299
4300            }
4301
4302        }
4303        catch (RecognitionException re) {
4304            reportError(re);
4305            recover(input,re);
4306        }
4307        finally {
4308            if ( state.backtracking>0 ) { memoize(input, 30, interfaceMethodDeclaration_StartIndex); }
4309        }
4310        dbg.location(587, 5);
4311
4312        }
4313        finally {
4314            dbg.exitRule(getGrammarFileName(), "interfaceMethodDeclaration");
4315            decRuleLevel();
4316            if ( getRuleLevel()==0 ) {dbg.terminate();}
4317        }
4318
4319        return ;
4320    }
4321    // $ANTLR end "interfaceMethodDeclaration"
4322
4323
4324    // $ANTLR start "interfaceFieldDeclaration"
4325    // src/com/google/doclava/parser/Java.g:589:1: interfaceFieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' ;
4326    public final void interfaceFieldDeclaration() throws RecognitionException {
4327        int interfaceFieldDeclaration_StartIndex = input.index();
4328        try { dbg.enterRule(getGrammarFileName(), "interfaceFieldDeclaration");
4329        if ( getRuleLevel()==0 ) {dbg.commence();}
4330        incRuleLevel();
4331        dbg.location(589, 1);
4332
4333        try {
4334            if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return ; }
4335            // src/com/google/doclava/parser/Java.g:595:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' )
4336            dbg.enterAlt(1);
4337
4338            // src/com/google/doclava/parser/Java.g:595:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';'
4339            {
4340            dbg.location(595,9);
4341            pushFollow(FOLLOW_modifiers_in_interfaceFieldDeclaration2376);
4342            modifiers();
4343
4344            state._fsp--;
4345            if (state.failed) return ;
4346            dbg.location(595,19);
4347            pushFollow(FOLLOW_type_in_interfaceFieldDeclaration2378);
4348            type();
4349
4350            state._fsp--;
4351            if (state.failed) return ;
4352            dbg.location(595,24);
4353            pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2380);
4354            variableDeclarator();
4355
4356            state._fsp--;
4357            if (state.failed) return ;
4358            dbg.location(596,9);
4359            // src/com/google/doclava/parser/Java.g:596:9: ( ',' variableDeclarator )*
4360            try { dbg.enterSubRule(58);
4361
4362            loop58:
4363            do {
4364                int alt58=2;
4365                try { dbg.enterDecision(58, decisionCanBacktrack[58]);
4366
4367                int LA58_0 = input.LA(1);
4368
4369                if ( (LA58_0==COMMA) ) {
4370                    alt58=1;
4371                }
4372
4373
4374                } finally {dbg.exitDecision(58);}
4375
4376                switch (alt58) {
4377		case 1 :
4378		    dbg.enterAlt(1);
4379
4380		    // src/com/google/doclava/parser/Java.g:596:10: ',' variableDeclarator
4381		    {
4382		    dbg.location(596,10);
4383		    match(input,COMMA,FOLLOW_COMMA_in_interfaceFieldDeclaration2391); if (state.failed) return ;
4384		    dbg.location(596,14);
4385		    pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration2393);
4386		    variableDeclarator();
4387
4388		    state._fsp--;
4389		    if (state.failed) return ;
4390
4391		    }
4392		    break;
4393
4394		default :
4395		    break loop58;
4396                }
4397            } while (true);
4398            } finally {dbg.exitSubRule(58);}
4399
4400            dbg.location(598,9);
4401            match(input,SEMI,FOLLOW_SEMI_in_interfaceFieldDeclaration2414); if (state.failed) return ;
4402
4403            }
4404
4405        }
4406        catch (RecognitionException re) {
4407            reportError(re);
4408            recover(input,re);
4409        }
4410        finally {
4411            if ( state.backtracking>0 ) { memoize(input, 31, interfaceFieldDeclaration_StartIndex); }
4412        }
4413        dbg.location(599, 5);
4414
4415        }
4416        finally {
4417            dbg.exitRule(getGrammarFileName(), "interfaceFieldDeclaration");
4418            decRuleLevel();
4419            if ( getRuleLevel()==0 ) {dbg.terminate();}
4420        }
4421
4422        return ;
4423    }
4424    // $ANTLR end "interfaceFieldDeclaration"
4425
4426
4427    // $ANTLR start "type"
4428    // src/com/google/doclava/parser/Java.g:602:1: type : ( classOrInterfaceType ( '[' ']' )* | primitiveType ( '[' ']' )* );
4429    public final void type() throws RecognitionException {
4430        int type_StartIndex = input.index();
4431        try { dbg.enterRule(getGrammarFileName(), "type");
4432        if ( getRuleLevel()==0 ) {dbg.commence();}
4433        incRuleLevel();
4434        dbg.location(602, 1);
4435
4436        try {
4437            if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return ; }
4438            // src/com/google/doclava/parser/Java.g:603:5: ( classOrInterfaceType ( '[' ']' )* | primitiveType ( '[' ']' )* )
4439            int alt61=2;
4440            try { dbg.enterDecision(61, decisionCanBacktrack[61]);
4441
4442            int LA61_0 = input.LA(1);
4443
4444            if ( (LA61_0==IDENTIFIER) ) {
4445                alt61=1;
4446            }
4447            else if ( (LA61_0==BOOLEAN||LA61_0==BYTE||LA61_0==CHAR||LA61_0==DOUBLE||LA61_0==FLOAT||LA61_0==INT||LA61_0==LONG||LA61_0==SHORT) ) {
4448                alt61=2;
4449            }
4450            else {
4451                if (state.backtracking>0) {state.failed=true; return ;}
4452                NoViableAltException nvae =
4453                    new NoViableAltException("", 61, 0, input);
4454
4455                dbg.recognitionException(nvae);
4456                throw nvae;
4457            }
4458            } finally {dbg.exitDecision(61);}
4459
4460            switch (alt61) {
4461                case 1 :
4462                    dbg.enterAlt(1);
4463
4464                    // src/com/google/doclava/parser/Java.g:603:9: classOrInterfaceType ( '[' ']' )*
4465                    {
4466                    dbg.location(603,9);
4467                    pushFollow(FOLLOW_classOrInterfaceType_in_type2434);
4468                    classOrInterfaceType();
4469
4470                    state._fsp--;
4471                    if (state.failed) return ;
4472                    dbg.location(604,9);
4473                    // src/com/google/doclava/parser/Java.g:604:9: ( '[' ']' )*
4474                    try { dbg.enterSubRule(59);
4475
4476                    loop59:
4477                    do {
4478                        int alt59=2;
4479                        try { dbg.enterDecision(59, decisionCanBacktrack[59]);
4480
4481                        int LA59_0 = input.LA(1);
4482
4483                        if ( (LA59_0==LBRACKET) ) {
4484                            alt59=1;
4485                        }
4486
4487
4488                        } finally {dbg.exitDecision(59);}
4489
4490                        switch (alt59) {
4491			case 1 :
4492			    dbg.enterAlt(1);
4493
4494			    // src/com/google/doclava/parser/Java.g:604:10: '[' ']'
4495			    {
4496			    dbg.location(604,10);
4497			    match(input,LBRACKET,FOLLOW_LBRACKET_in_type2445); if (state.failed) return ;
4498			    dbg.location(604,14);
4499			    match(input,RBRACKET,FOLLOW_RBRACKET_in_type2447); if (state.failed) return ;
4500
4501			    }
4502			    break;
4503
4504			default :
4505			    break loop59;
4506                        }
4507                    } while (true);
4508                    } finally {dbg.exitSubRule(59);}
4509
4510
4511                    }
4512                    break;
4513                case 2 :
4514                    dbg.enterAlt(2);
4515
4516                    // src/com/google/doclava/parser/Java.g:606:9: primitiveType ( '[' ']' )*
4517                    {
4518                    dbg.location(606,9);
4519                    pushFollow(FOLLOW_primitiveType_in_type2468);
4520                    primitiveType();
4521
4522                    state._fsp--;
4523                    if (state.failed) return ;
4524                    dbg.location(607,9);
4525                    // src/com/google/doclava/parser/Java.g:607:9: ( '[' ']' )*
4526                    try { dbg.enterSubRule(60);
4527
4528                    loop60:
4529                    do {
4530                        int alt60=2;
4531                        try { dbg.enterDecision(60, decisionCanBacktrack[60]);
4532
4533                        int LA60_0 = input.LA(1);
4534
4535                        if ( (LA60_0==LBRACKET) ) {
4536                            alt60=1;
4537                        }
4538
4539
4540                        } finally {dbg.exitDecision(60);}
4541
4542                        switch (alt60) {
4543			case 1 :
4544			    dbg.enterAlt(1);
4545
4546			    // src/com/google/doclava/parser/Java.g:607:10: '[' ']'
4547			    {
4548			    dbg.location(607,10);
4549			    match(input,LBRACKET,FOLLOW_LBRACKET_in_type2479); if (state.failed) return ;
4550			    dbg.location(607,14);
4551			    match(input,RBRACKET,FOLLOW_RBRACKET_in_type2481); if (state.failed) return ;
4552
4553			    }
4554			    break;
4555
4556			default :
4557			    break loop60;
4558                        }
4559                    } while (true);
4560                    } finally {dbg.exitSubRule(60);}
4561
4562
4563                    }
4564                    break;
4565
4566            }
4567        }
4568        catch (RecognitionException re) {
4569            reportError(re);
4570            recover(input,re);
4571        }
4572        finally {
4573            if ( state.backtracking>0 ) { memoize(input, 32, type_StartIndex); }
4574        }
4575        dbg.location(609, 5);
4576
4577        }
4578        finally {
4579            dbg.exitRule(getGrammarFileName(), "type");
4580            decRuleLevel();
4581            if ( getRuleLevel()==0 ) {dbg.terminate();}
4582        }
4583
4584        return ;
4585    }
4586    // $ANTLR end "type"
4587
4588
4589    // $ANTLR start "classOrInterfaceType"
4590    // src/com/google/doclava/parser/Java.g:612:1: classOrInterfaceType : IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* ;
4591    public final void classOrInterfaceType() throws RecognitionException {
4592        int classOrInterfaceType_StartIndex = input.index();
4593        try { dbg.enterRule(getGrammarFileName(), "classOrInterfaceType");
4594        if ( getRuleLevel()==0 ) {dbg.commence();}
4595        incRuleLevel();
4596        dbg.location(612, 1);
4597
4598        try {
4599            if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return ; }
4600            // src/com/google/doclava/parser/Java.g:613:5: ( IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )* )
4601            dbg.enterAlt(1);
4602
4603            // src/com/google/doclava/parser/Java.g:613:9: IDENTIFIER ( typeArguments )? ( '.' IDENTIFIER ( typeArguments )? )*
4604            {
4605            dbg.location(613,9);
4606            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType2512); if (state.failed) return ;
4607            dbg.location(614,9);
4608            // src/com/google/doclava/parser/Java.g:614:9: ( typeArguments )?
4609            int alt62=2;
4610            try { dbg.enterSubRule(62);
4611            try { dbg.enterDecision(62, decisionCanBacktrack[62]);
4612
4613            int LA62_0 = input.LA(1);
4614
4615            if ( (LA62_0==LT) ) {
4616                int LA62_1 = input.LA(2);
4617
4618                if ( (LA62_1==IDENTIFIER||LA62_1==BOOLEAN||LA62_1==BYTE||LA62_1==CHAR||LA62_1==DOUBLE||LA62_1==FLOAT||LA62_1==INT||LA62_1==LONG||LA62_1==SHORT||LA62_1==QUES) ) {
4619                    alt62=1;
4620                }
4621            }
4622            } finally {dbg.exitDecision(62);}
4623
4624            switch (alt62) {
4625                case 1 :
4626                    dbg.enterAlt(1);
4627
4628                    // src/com/google/doclava/parser/Java.g:614:10: typeArguments
4629                    {
4630                    dbg.location(614,10);
4631                    pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType2523);
4632                    typeArguments();
4633
4634                    state._fsp--;
4635                    if (state.failed) return ;
4636
4637                    }
4638                    break;
4639
4640            }
4641            } finally {dbg.exitSubRule(62);}
4642
4643            dbg.location(616,9);
4644            // src/com/google/doclava/parser/Java.g:616:9: ( '.' IDENTIFIER ( typeArguments )? )*
4645            try { dbg.enterSubRule(64);
4646
4647            loop64:
4648            do {
4649                int alt64=2;
4650                try { dbg.enterDecision(64, decisionCanBacktrack[64]);
4651
4652                int LA64_0 = input.LA(1);
4653
4654                if ( (LA64_0==DOT) ) {
4655                    alt64=1;
4656                }
4657
4658
4659                } finally {dbg.exitDecision(64);}
4660
4661                switch (alt64) {
4662		case 1 :
4663		    dbg.enterAlt(1);
4664
4665		    // src/com/google/doclava/parser/Java.g:616:10: '.' IDENTIFIER ( typeArguments )?
4666		    {
4667		    dbg.location(616,10);
4668		    match(input,DOT,FOLLOW_DOT_in_classOrInterfaceType2545); if (state.failed) return ;
4669		    dbg.location(616,14);
4670		    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType2547); if (state.failed) return ;
4671		    dbg.location(617,13);
4672		    // src/com/google/doclava/parser/Java.g:617:13: ( typeArguments )?
4673		    int alt63=2;
4674		    try { dbg.enterSubRule(63);
4675		    try { dbg.enterDecision(63, decisionCanBacktrack[63]);
4676
4677		    int LA63_0 = input.LA(1);
4678
4679		    if ( (LA63_0==LT) ) {
4680		        int LA63_1 = input.LA(2);
4681
4682		        if ( (LA63_1==IDENTIFIER||LA63_1==BOOLEAN||LA63_1==BYTE||LA63_1==CHAR||LA63_1==DOUBLE||LA63_1==FLOAT||LA63_1==INT||LA63_1==LONG||LA63_1==SHORT||LA63_1==QUES) ) {
4683		            alt63=1;
4684		        }
4685		    }
4686		    } finally {dbg.exitDecision(63);}
4687
4688		    switch (alt63) {
4689		        case 1 :
4690		            dbg.enterAlt(1);
4691
4692		            // src/com/google/doclava/parser/Java.g:617:14: typeArguments
4693		            {
4694		            dbg.location(617,14);
4695		            pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType2562);
4696		            typeArguments();
4697
4698		            state._fsp--;
4699		            if (state.failed) return ;
4700
4701		            }
4702		            break;
4703
4704		    }
4705		    } finally {dbg.exitSubRule(63);}
4706
4707
4708		    }
4709		    break;
4710
4711		default :
4712		    break loop64;
4713                }
4714            } while (true);
4715            } finally {dbg.exitSubRule(64);}
4716
4717
4718            }
4719
4720        }
4721        catch (RecognitionException re) {
4722            reportError(re);
4723            recover(input,re);
4724        }
4725        finally {
4726            if ( state.backtracking>0 ) { memoize(input, 33, classOrInterfaceType_StartIndex); }
4727        }
4728        dbg.location(620, 5);
4729
4730        }
4731        finally {
4732            dbg.exitRule(getGrammarFileName(), "classOrInterfaceType");
4733            decRuleLevel();
4734            if ( getRuleLevel()==0 ) {dbg.terminate();}
4735        }
4736
4737        return ;
4738    }
4739    // $ANTLR end "classOrInterfaceType"
4740
4741
4742    // $ANTLR start "primitiveType"
4743    // src/com/google/doclava/parser/Java.g:622:1: primitiveType : ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' );
4744    public final void primitiveType() throws RecognitionException {
4745        int primitiveType_StartIndex = input.index();
4746        try { dbg.enterRule(getGrammarFileName(), "primitiveType");
4747        if ( getRuleLevel()==0 ) {dbg.commence();}
4748        incRuleLevel();
4749        dbg.location(622, 1);
4750
4751        try {
4752            if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return ; }
4753            // src/com/google/doclava/parser/Java.g:623:5: ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' )
4754            dbg.enterAlt(1);
4755
4756            // src/com/google/doclava/parser/Java.g:
4757            {
4758            dbg.location(623,5);
4759            if ( input.LA(1)==BOOLEAN||input.LA(1)==BYTE||input.LA(1)==CHAR||input.LA(1)==DOUBLE||input.LA(1)==FLOAT||input.LA(1)==INT||input.LA(1)==LONG||input.LA(1)==SHORT ) {
4760                input.consume();
4761                state.errorRecovery=false;state.failed=false;
4762            }
4763            else {
4764                if (state.backtracking>0) {state.failed=true; return ;}
4765                MismatchedSetException mse = new MismatchedSetException(null,input);
4766                dbg.recognitionException(mse);
4767                throw mse;
4768            }
4769
4770
4771            }
4772
4773        }
4774        catch (RecognitionException re) {
4775            reportError(re);
4776            recover(input,re);
4777        }
4778        finally {
4779            if ( state.backtracking>0 ) { memoize(input, 34, primitiveType_StartIndex); }
4780        }
4781        dbg.location(631, 5);
4782
4783        }
4784        finally {
4785            dbg.exitRule(getGrammarFileName(), "primitiveType");
4786            decRuleLevel();
4787            if ( getRuleLevel()==0 ) {dbg.terminate();}
4788        }
4789
4790        return ;
4791    }
4792    // $ANTLR end "primitiveType"
4793
4794
4795    // $ANTLR start "typeArguments"
4796    // src/com/google/doclava/parser/Java.g:633:1: typeArguments : '<' typeArgument ( ',' typeArgument )* '>' ;
4797    public final void typeArguments() throws RecognitionException {
4798        int typeArguments_StartIndex = input.index();
4799        try { dbg.enterRule(getGrammarFileName(), "typeArguments");
4800        if ( getRuleLevel()==0 ) {dbg.commence();}
4801        incRuleLevel();
4802        dbg.location(633, 1);
4803
4804        try {
4805            if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return ; }
4806            // src/com/google/doclava/parser/Java.g:634:5: ( '<' typeArgument ( ',' typeArgument )* '>' )
4807            dbg.enterAlt(1);
4808
4809            // src/com/google/doclava/parser/Java.g:634:9: '<' typeArgument ( ',' typeArgument )* '>'
4810            {
4811            dbg.location(634,9);
4812            match(input,LT,FOLLOW_LT_in_typeArguments2696); if (state.failed) return ;
4813            dbg.location(634,13);
4814            pushFollow(FOLLOW_typeArgument_in_typeArguments2698);
4815            typeArgument();
4816
4817            state._fsp--;
4818            if (state.failed) return ;
4819            dbg.location(635,9);
4820            // src/com/google/doclava/parser/Java.g:635:9: ( ',' typeArgument )*
4821            try { dbg.enterSubRule(65);
4822
4823            loop65:
4824            do {
4825                int alt65=2;
4826                try { dbg.enterDecision(65, decisionCanBacktrack[65]);
4827
4828                int LA65_0 = input.LA(1);
4829
4830                if ( (LA65_0==COMMA) ) {
4831                    alt65=1;
4832                }
4833
4834
4835                } finally {dbg.exitDecision(65);}
4836
4837                switch (alt65) {
4838		case 1 :
4839		    dbg.enterAlt(1);
4840
4841		    // src/com/google/doclava/parser/Java.g:635:10: ',' typeArgument
4842		    {
4843		    dbg.location(635,10);
4844		    match(input,COMMA,FOLLOW_COMMA_in_typeArguments2709); if (state.failed) return ;
4845		    dbg.location(635,14);
4846		    pushFollow(FOLLOW_typeArgument_in_typeArguments2711);
4847		    typeArgument();
4848
4849		    state._fsp--;
4850		    if (state.failed) return ;
4851
4852		    }
4853		    break;
4854
4855		default :
4856		    break loop65;
4857                }
4858            } while (true);
4859            } finally {dbg.exitSubRule(65);}
4860
4861            dbg.location(637,9);
4862            match(input,GT,FOLLOW_GT_in_typeArguments2732); if (state.failed) return ;
4863
4864            }
4865
4866        }
4867        catch (RecognitionException re) {
4868            reportError(re);
4869            recover(input,re);
4870        }
4871        finally {
4872            if ( state.backtracking>0 ) { memoize(input, 35, typeArguments_StartIndex); }
4873        }
4874        dbg.location(638, 5);
4875
4876        }
4877        finally {
4878            dbg.exitRule(getGrammarFileName(), "typeArguments");
4879            decRuleLevel();
4880            if ( getRuleLevel()==0 ) {dbg.terminate();}
4881        }
4882
4883        return ;
4884    }
4885    // $ANTLR end "typeArguments"
4886
4887
4888    // $ANTLR start "typeArgument"
4889    // src/com/google/doclava/parser/Java.g:640:1: typeArgument : ( type | '?' ( ( 'extends' | 'super' ) type )? );
4890    public final void typeArgument() throws RecognitionException {
4891        int typeArgument_StartIndex = input.index();
4892        try { dbg.enterRule(getGrammarFileName(), "typeArgument");
4893        if ( getRuleLevel()==0 ) {dbg.commence();}
4894        incRuleLevel();
4895        dbg.location(640, 1);
4896
4897        try {
4898            if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return ; }
4899            // src/com/google/doclava/parser/Java.g:641:5: ( type | '?' ( ( 'extends' | 'super' ) type )? )
4900            int alt67=2;
4901            try { dbg.enterDecision(67, decisionCanBacktrack[67]);
4902
4903            int LA67_0 = input.LA(1);
4904
4905            if ( (LA67_0==IDENTIFIER||LA67_0==BOOLEAN||LA67_0==BYTE||LA67_0==CHAR||LA67_0==DOUBLE||LA67_0==FLOAT||LA67_0==INT||LA67_0==LONG||LA67_0==SHORT) ) {
4906                alt67=1;
4907            }
4908            else if ( (LA67_0==QUES) ) {
4909                alt67=2;
4910            }
4911            else {
4912                if (state.backtracking>0) {state.failed=true; return ;}
4913                NoViableAltException nvae =
4914                    new NoViableAltException("", 67, 0, input);
4915
4916                dbg.recognitionException(nvae);
4917                throw nvae;
4918            }
4919            } finally {dbg.exitDecision(67);}
4920
4921            switch (alt67) {
4922                case 1 :
4923                    dbg.enterAlt(1);
4924
4925                    // src/com/google/doclava/parser/Java.g:641:9: type
4926                    {
4927                    dbg.location(641,9);
4928                    pushFollow(FOLLOW_type_in_typeArgument2751);
4929                    type();
4930
4931                    state._fsp--;
4932                    if (state.failed) return ;
4933
4934                    }
4935                    break;
4936                case 2 :
4937                    dbg.enterAlt(2);
4938
4939                    // src/com/google/doclava/parser/Java.g:642:9: '?' ( ( 'extends' | 'super' ) type )?
4940                    {
4941                    dbg.location(642,9);
4942                    match(input,QUES,FOLLOW_QUES_in_typeArgument2761); if (state.failed) return ;
4943                    dbg.location(643,9);
4944                    // src/com/google/doclava/parser/Java.g:643:9: ( ( 'extends' | 'super' ) type )?
4945                    int alt66=2;
4946                    try { dbg.enterSubRule(66);
4947                    try { dbg.enterDecision(66, decisionCanBacktrack[66]);
4948
4949                    int LA66_0 = input.LA(1);
4950
4951                    if ( (LA66_0==EXTENDS||LA66_0==SUPER) ) {
4952                        alt66=1;
4953                    }
4954                    } finally {dbg.exitDecision(66);}
4955
4956                    switch (alt66) {
4957                        case 1 :
4958                            dbg.enterAlt(1);
4959
4960                            // src/com/google/doclava/parser/Java.g:644:13: ( 'extends' | 'super' ) type
4961                            {
4962                            dbg.location(644,13);
4963                            if ( input.LA(1)==EXTENDS||input.LA(1)==SUPER ) {
4964                                input.consume();
4965                                state.errorRecovery=false;state.failed=false;
4966                            }
4967                            else {
4968                                if (state.backtracking>0) {state.failed=true; return ;}
4969                                MismatchedSetException mse = new MismatchedSetException(null,input);
4970                                dbg.recognitionException(mse);
4971                                throw mse;
4972                            }
4973
4974                            dbg.location(647,13);
4975                            pushFollow(FOLLOW_type_in_typeArgument2829);
4976                            type();
4977
4978                            state._fsp--;
4979                            if (state.failed) return ;
4980
4981                            }
4982                            break;
4983
4984                    }
4985                    } finally {dbg.exitSubRule(66);}
4986
4987
4988                    }
4989                    break;
4990
4991            }
4992        }
4993        catch (RecognitionException re) {
4994            reportError(re);
4995            recover(input,re);
4996        }
4997        finally {
4998            if ( state.backtracking>0 ) { memoize(input, 36, typeArgument_StartIndex); }
4999        }
5000        dbg.location(649, 5);
5001
5002        }
5003        finally {
5004            dbg.exitRule(getGrammarFileName(), "typeArgument");
5005            decRuleLevel();
5006            if ( getRuleLevel()==0 ) {dbg.terminate();}
5007        }
5008
5009        return ;
5010    }
5011    // $ANTLR end "typeArgument"
5012
5013
5014    // $ANTLR start "qualifiedNameList"
5015    // src/com/google/doclava/parser/Java.g:651:1: qualifiedNameList : qualifiedName ( ',' qualifiedName )* ;
5016    public final void qualifiedNameList() throws RecognitionException {
5017        int qualifiedNameList_StartIndex = input.index();
5018        try { dbg.enterRule(getGrammarFileName(), "qualifiedNameList");
5019        if ( getRuleLevel()==0 ) {dbg.commence();}
5020        incRuleLevel();
5021        dbg.location(651, 1);
5022
5023        try {
5024            if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return ; }
5025            // src/com/google/doclava/parser/Java.g:652:5: ( qualifiedName ( ',' qualifiedName )* )
5026            dbg.enterAlt(1);
5027
5028            // src/com/google/doclava/parser/Java.g:652:9: qualifiedName ( ',' qualifiedName )*
5029            {
5030            dbg.location(652,9);
5031            pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2859);
5032            qualifiedName();
5033
5034            state._fsp--;
5035            if (state.failed) return ;
5036            dbg.location(653,9);
5037            // src/com/google/doclava/parser/Java.g:653:9: ( ',' qualifiedName )*
5038            try { dbg.enterSubRule(68);
5039
5040            loop68:
5041            do {
5042                int alt68=2;
5043                try { dbg.enterDecision(68, decisionCanBacktrack[68]);
5044
5045                int LA68_0 = input.LA(1);
5046
5047                if ( (LA68_0==COMMA) ) {
5048                    alt68=1;
5049                }
5050
5051
5052                } finally {dbg.exitDecision(68);}
5053
5054                switch (alt68) {
5055		case 1 :
5056		    dbg.enterAlt(1);
5057
5058		    // src/com/google/doclava/parser/Java.g:653:10: ',' qualifiedName
5059		    {
5060		    dbg.location(653,10);
5061		    match(input,COMMA,FOLLOW_COMMA_in_qualifiedNameList2870); if (state.failed) return ;
5062		    dbg.location(653,14);
5063		    pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2872);
5064		    qualifiedName();
5065
5066		    state._fsp--;
5067		    if (state.failed) return ;
5068
5069		    }
5070		    break;
5071
5072		default :
5073		    break loop68;
5074                }
5075            } while (true);
5076            } finally {dbg.exitSubRule(68);}
5077
5078
5079            }
5080
5081        }
5082        catch (RecognitionException re) {
5083            reportError(re);
5084            recover(input,re);
5085        }
5086        finally {
5087            if ( state.backtracking>0 ) { memoize(input, 37, qualifiedNameList_StartIndex); }
5088        }
5089        dbg.location(655, 5);
5090
5091        }
5092        finally {
5093            dbg.exitRule(getGrammarFileName(), "qualifiedNameList");
5094            decRuleLevel();
5095            if ( getRuleLevel()==0 ) {dbg.terminate();}
5096        }
5097
5098        return ;
5099    }
5100    // $ANTLR end "qualifiedNameList"
5101
5102
5103    // $ANTLR start "formalParameters"
5104    // src/com/google/doclava/parser/Java.g:657:1: formalParameters : '(' ( formalParameterDecls )? ')' ;
5105    public final void formalParameters() throws RecognitionException {
5106        int formalParameters_StartIndex = input.index();
5107        try { dbg.enterRule(getGrammarFileName(), "formalParameters");
5108        if ( getRuleLevel()==0 ) {dbg.commence();}
5109        incRuleLevel();
5110        dbg.location(657, 1);
5111
5112        try {
5113            if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return ; }
5114            // src/com/google/doclava/parser/Java.g:658:5: ( '(' ( formalParameterDecls )? ')' )
5115            dbg.enterAlt(1);
5116
5117            // src/com/google/doclava/parser/Java.g:658:9: '(' ( formalParameterDecls )? ')'
5118            {
5119            dbg.location(658,9);
5120            match(input,LPAREN,FOLLOW_LPAREN_in_formalParameters2902); if (state.failed) return ;
5121            dbg.location(659,9);
5122            // src/com/google/doclava/parser/Java.g:659:9: ( formalParameterDecls )?
5123            int alt69=2;
5124            try { dbg.enterSubRule(69);
5125            try { dbg.enterDecision(69, decisionCanBacktrack[69]);
5126
5127            int LA69_0 = input.LA(1);
5128
5129            if ( (LA69_0==IDENTIFIER||LA69_0==BOOLEAN||LA69_0==BYTE||LA69_0==CHAR||LA69_0==DOUBLE||LA69_0==FINAL||LA69_0==FLOAT||LA69_0==INT||LA69_0==LONG||LA69_0==SHORT||LA69_0==MONKEYS_AT) ) {
5130                alt69=1;
5131            }
5132            } finally {dbg.exitDecision(69);}
5133
5134            switch (alt69) {
5135                case 1 :
5136                    dbg.enterAlt(1);
5137
5138                    // src/com/google/doclava/parser/Java.g:659:10: formalParameterDecls
5139                    {
5140                    dbg.location(659,10);
5141                    pushFollow(FOLLOW_formalParameterDecls_in_formalParameters2913);
5142                    formalParameterDecls();
5143
5144                    state._fsp--;
5145                    if (state.failed) return ;
5146
5147                    }
5148                    break;
5149
5150            }
5151            } finally {dbg.exitSubRule(69);}
5152
5153            dbg.location(661,9);
5154            match(input,RPAREN,FOLLOW_RPAREN_in_formalParameters2934); if (state.failed) return ;
5155
5156            }
5157
5158        }
5159        catch (RecognitionException re) {
5160            reportError(re);
5161            recover(input,re);
5162        }
5163        finally {
5164            if ( state.backtracking>0 ) { memoize(input, 38, formalParameters_StartIndex); }
5165        }
5166        dbg.location(662, 5);
5167
5168        }
5169        finally {
5170            dbg.exitRule(getGrammarFileName(), "formalParameters");
5171            decRuleLevel();
5172            if ( getRuleLevel()==0 ) {dbg.terminate();}
5173        }
5174
5175        return ;
5176    }
5177    // $ANTLR end "formalParameters"
5178
5179
5180    // $ANTLR start "formalParameterDecls"
5181    // src/com/google/doclava/parser/Java.g:664:1: formalParameterDecls : ( ellipsisParameterDecl | normalParameterDecl ( ',' normalParameterDecl )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl );
5182    public final void formalParameterDecls() throws RecognitionException {
5183        int formalParameterDecls_StartIndex = input.index();
5184        try { dbg.enterRule(getGrammarFileName(), "formalParameterDecls");
5185        if ( getRuleLevel()==0 ) {dbg.commence();}
5186        incRuleLevel();
5187        dbg.location(664, 1);
5188
5189        try {
5190            if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return ; }
5191            // src/com/google/doclava/parser/Java.g:665:5: ( ellipsisParameterDecl | normalParameterDecl ( ',' normalParameterDecl )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl )
5192            int alt72=3;
5193            try { dbg.enterDecision(72, decisionCanBacktrack[72]);
5194
5195            switch ( input.LA(1) ) {
5196            case FINAL:
5197                {
5198                int LA72_1 = input.LA(2);
5199
5200                if ( (synpred96_Java()) ) {
5201                    alt72=1;
5202                }
5203                else if ( (synpred98_Java()) ) {
5204                    alt72=2;
5205                }
5206                else if ( (true) ) {
5207                    alt72=3;
5208                }
5209                else {
5210                    if (state.backtracking>0) {state.failed=true; return ;}
5211                    NoViableAltException nvae =
5212                        new NoViableAltException("", 72, 1, input);
5213
5214                    dbg.recognitionException(nvae);
5215                    throw nvae;
5216                }
5217                }
5218                break;
5219            case MONKEYS_AT:
5220                {
5221                int LA72_2 = input.LA(2);
5222
5223                if ( (synpred96_Java()) ) {
5224                    alt72=1;
5225                }
5226                else if ( (synpred98_Java()) ) {
5227                    alt72=2;
5228                }
5229                else if ( (true) ) {
5230                    alt72=3;
5231                }
5232                else {
5233                    if (state.backtracking>0) {state.failed=true; return ;}
5234                    NoViableAltException nvae =
5235                        new NoViableAltException("", 72, 2, input);
5236
5237                    dbg.recognitionException(nvae);
5238                    throw nvae;
5239                }
5240                }
5241                break;
5242            case IDENTIFIER:
5243                {
5244                int LA72_3 = input.LA(2);
5245
5246                if ( (synpred96_Java()) ) {
5247                    alt72=1;
5248                }
5249                else if ( (synpred98_Java()) ) {
5250                    alt72=2;
5251                }
5252                else if ( (true) ) {
5253                    alt72=3;
5254                }
5255                else {
5256                    if (state.backtracking>0) {state.failed=true; return ;}
5257                    NoViableAltException nvae =
5258                        new NoViableAltException("", 72, 3, input);
5259
5260                    dbg.recognitionException(nvae);
5261                    throw nvae;
5262                }
5263                }
5264                break;
5265            case BOOLEAN:
5266            case BYTE:
5267            case CHAR:
5268            case DOUBLE:
5269            case FLOAT:
5270            case INT:
5271            case LONG:
5272            case SHORT:
5273                {
5274                int LA72_4 = input.LA(2);
5275
5276                if ( (synpred96_Java()) ) {
5277                    alt72=1;
5278                }
5279                else if ( (synpred98_Java()) ) {
5280                    alt72=2;
5281                }
5282                else if ( (true) ) {
5283                    alt72=3;
5284                }
5285                else {
5286                    if (state.backtracking>0) {state.failed=true; return ;}
5287                    NoViableAltException nvae =
5288                        new NoViableAltException("", 72, 4, input);
5289
5290                    dbg.recognitionException(nvae);
5291                    throw nvae;
5292                }
5293                }
5294                break;
5295            default:
5296                if (state.backtracking>0) {state.failed=true; return ;}
5297                NoViableAltException nvae =
5298                    new NoViableAltException("", 72, 0, input);
5299
5300                dbg.recognitionException(nvae);
5301                throw nvae;
5302            }
5303
5304            } finally {dbg.exitDecision(72);}
5305
5306            switch (alt72) {
5307                case 1 :
5308                    dbg.enterAlt(1);
5309
5310                    // src/com/google/doclava/parser/Java.g:665:9: ellipsisParameterDecl
5311                    {
5312                    dbg.location(665,9);
5313                    pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls2953);
5314                    ellipsisParameterDecl();
5315
5316                    state._fsp--;
5317                    if (state.failed) return ;
5318
5319                    }
5320                    break;
5321                case 2 :
5322                    dbg.enterAlt(2);
5323
5324                    // src/com/google/doclava/parser/Java.g:666:9: normalParameterDecl ( ',' normalParameterDecl )*
5325                    {
5326                    dbg.location(666,9);
5327                    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2963);
5328                    normalParameterDecl();
5329
5330                    state._fsp--;
5331                    if (state.failed) return ;
5332                    dbg.location(667,9);
5333                    // src/com/google/doclava/parser/Java.g:667:9: ( ',' normalParameterDecl )*
5334                    try { dbg.enterSubRule(70);
5335
5336                    loop70:
5337                    do {
5338                        int alt70=2;
5339                        try { dbg.enterDecision(70, decisionCanBacktrack[70]);
5340
5341                        int LA70_0 = input.LA(1);
5342
5343                        if ( (LA70_0==COMMA) ) {
5344                            alt70=1;
5345                        }
5346
5347
5348                        } finally {dbg.exitDecision(70);}
5349
5350                        switch (alt70) {
5351			case 1 :
5352			    dbg.enterAlt(1);
5353
5354			    // src/com/google/doclava/parser/Java.g:667:10: ',' normalParameterDecl
5355			    {
5356			    dbg.location(667,10);
5357			    match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls2974); if (state.failed) return ;
5358			    dbg.location(667,14);
5359			    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2976);
5360			    normalParameterDecl();
5361
5362			    state._fsp--;
5363			    if (state.failed) return ;
5364
5365			    }
5366			    break;
5367
5368			default :
5369			    break loop70;
5370                        }
5371                    } while (true);
5372                    } finally {dbg.exitSubRule(70);}
5373
5374
5375                    }
5376                    break;
5377                case 3 :
5378                    dbg.enterAlt(3);
5379
5380                    // src/com/google/doclava/parser/Java.g:669:9: ( normalParameterDecl ',' )+ ellipsisParameterDecl
5381                    {
5382                    dbg.location(669,9);
5383                    // src/com/google/doclava/parser/Java.g:669:9: ( normalParameterDecl ',' )+
5384                    int cnt71=0;
5385                    try { dbg.enterSubRule(71);
5386
5387                    loop71:
5388                    do {
5389                        int alt71=2;
5390                        try { dbg.enterDecision(71, decisionCanBacktrack[71]);
5391
5392                        switch ( input.LA(1) ) {
5393                        case FINAL:
5394                            {
5395                            int LA71_1 = input.LA(2);
5396
5397                            if ( (synpred99_Java()) ) {
5398                                alt71=1;
5399                            }
5400
5401
5402                            }
5403                            break;
5404                        case MONKEYS_AT:
5405                            {
5406                            int LA71_2 = input.LA(2);
5407
5408                            if ( (synpred99_Java()) ) {
5409                                alt71=1;
5410                            }
5411
5412
5413                            }
5414                            break;
5415                        case IDENTIFIER:
5416                            {
5417                            int LA71_3 = input.LA(2);
5418
5419                            if ( (synpred99_Java()) ) {
5420                                alt71=1;
5421                            }
5422
5423
5424                            }
5425                            break;
5426                        case BOOLEAN:
5427                        case BYTE:
5428                        case CHAR:
5429                        case DOUBLE:
5430                        case FLOAT:
5431                        case INT:
5432                        case LONG:
5433                        case SHORT:
5434                            {
5435                            int LA71_4 = input.LA(2);
5436
5437                            if ( (synpred99_Java()) ) {
5438                                alt71=1;
5439                            }
5440
5441
5442                            }
5443                            break;
5444
5445                        }
5446
5447                        } finally {dbg.exitDecision(71);}
5448
5449                        switch (alt71) {
5450			case 1 :
5451			    dbg.enterAlt(1);
5452
5453			    // src/com/google/doclava/parser/Java.g:669:10: normalParameterDecl ','
5454			    {
5455			    dbg.location(669,10);
5456			    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls2998);
5457			    normalParameterDecl();
5458
5459			    state._fsp--;
5460			    if (state.failed) return ;
5461			    dbg.location(670,9);
5462			    match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls3008); if (state.failed) return ;
5463
5464			    }
5465			    break;
5466
5467			default :
5468			    if ( cnt71 >= 1 ) break loop71;
5469			    if (state.backtracking>0) {state.failed=true; return ;}
5470                                EarlyExitException eee =
5471                                    new EarlyExitException(71, input);
5472                                dbg.recognitionException(eee);
5473
5474                                throw eee;
5475                        }
5476                        cnt71++;
5477                    } while (true);
5478                    } finally {dbg.exitSubRule(71);}
5479
5480                    dbg.location(672,9);
5481                    pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls3029);
5482                    ellipsisParameterDecl();
5483
5484                    state._fsp--;
5485                    if (state.failed) return ;
5486
5487                    }
5488                    break;
5489
5490            }
5491        }
5492        catch (RecognitionException re) {
5493            reportError(re);
5494            recover(input,re);
5495        }
5496        finally {
5497            if ( state.backtracking>0 ) { memoize(input, 39, formalParameterDecls_StartIndex); }
5498        }
5499        dbg.location(673, 5);
5500
5501        }
5502        finally {
5503            dbg.exitRule(getGrammarFileName(), "formalParameterDecls");
5504            decRuleLevel();
5505            if ( getRuleLevel()==0 ) {dbg.terminate();}
5506        }
5507
5508        return ;
5509    }
5510    // $ANTLR end "formalParameterDecls"
5511
5512
5513    // $ANTLR start "normalParameterDecl"
5514    // src/com/google/doclava/parser/Java.g:675:1: normalParameterDecl : variableModifiers type IDENTIFIER ( '[' ']' )* ;
5515    public final void normalParameterDecl() throws RecognitionException {
5516        int normalParameterDecl_StartIndex = input.index();
5517        try { dbg.enterRule(getGrammarFileName(), "normalParameterDecl");
5518        if ( getRuleLevel()==0 ) {dbg.commence();}
5519        incRuleLevel();
5520        dbg.location(675, 1);
5521
5522        try {
5523            if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return ; }
5524            // src/com/google/doclava/parser/Java.g:676:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* )
5525            dbg.enterAlt(1);
5526
5527            // src/com/google/doclava/parser/Java.g:676:9: variableModifiers type IDENTIFIER ( '[' ']' )*
5528            {
5529            dbg.location(676,9);
5530            pushFollow(FOLLOW_variableModifiers_in_normalParameterDecl3048);
5531            variableModifiers();
5532
5533            state._fsp--;
5534            if (state.failed) return ;
5535            dbg.location(676,27);
5536            pushFollow(FOLLOW_type_in_normalParameterDecl3050);
5537            type();
5538
5539            state._fsp--;
5540            if (state.failed) return ;
5541            dbg.location(676,32);
5542            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalParameterDecl3052); if (state.failed) return ;
5543            dbg.location(677,9);
5544            // src/com/google/doclava/parser/Java.g:677:9: ( '[' ']' )*
5545            try { dbg.enterSubRule(73);
5546
5547            loop73:
5548            do {
5549                int alt73=2;
5550                try { dbg.enterDecision(73, decisionCanBacktrack[73]);
5551
5552                int LA73_0 = input.LA(1);
5553
5554                if ( (LA73_0==LBRACKET) ) {
5555                    alt73=1;
5556                }
5557
5558
5559                } finally {dbg.exitDecision(73);}
5560
5561                switch (alt73) {
5562		case 1 :
5563		    dbg.enterAlt(1);
5564
5565		    // src/com/google/doclava/parser/Java.g:677:10: '[' ']'
5566		    {
5567		    dbg.location(677,10);
5568		    match(input,LBRACKET,FOLLOW_LBRACKET_in_normalParameterDecl3063); if (state.failed) return ;
5569		    dbg.location(677,14);
5570		    match(input,RBRACKET,FOLLOW_RBRACKET_in_normalParameterDecl3065); if (state.failed) return ;
5571
5572		    }
5573		    break;
5574
5575		default :
5576		    break loop73;
5577                }
5578            } while (true);
5579            } finally {dbg.exitSubRule(73);}
5580
5581
5582            }
5583
5584        }
5585        catch (RecognitionException re) {
5586            reportError(re);
5587            recover(input,re);
5588        }
5589        finally {
5590            if ( state.backtracking>0 ) { memoize(input, 40, normalParameterDecl_StartIndex); }
5591        }
5592        dbg.location(679, 5);
5593
5594        }
5595        finally {
5596            dbg.exitRule(getGrammarFileName(), "normalParameterDecl");
5597            decRuleLevel();
5598            if ( getRuleLevel()==0 ) {dbg.terminate();}
5599        }
5600
5601        return ;
5602    }
5603    // $ANTLR end "normalParameterDecl"
5604
5605
5606    // $ANTLR start "ellipsisParameterDecl"
5607    // src/com/google/doclava/parser/Java.g:681:1: ellipsisParameterDecl : variableModifiers type '...' IDENTIFIER ;
5608    public final void ellipsisParameterDecl() throws RecognitionException {
5609        int ellipsisParameterDecl_StartIndex = input.index();
5610        try { dbg.enterRule(getGrammarFileName(), "ellipsisParameterDecl");
5611        if ( getRuleLevel()==0 ) {dbg.commence();}
5612        incRuleLevel();
5613        dbg.location(681, 1);
5614
5615        try {
5616            if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return ; }
5617            // src/com/google/doclava/parser/Java.g:682:5: ( variableModifiers type '...' IDENTIFIER )
5618            dbg.enterAlt(1);
5619
5620            // src/com/google/doclava/parser/Java.g:682:9: variableModifiers type '...' IDENTIFIER
5621            {
5622            dbg.location(682,9);
5623            pushFollow(FOLLOW_variableModifiers_in_ellipsisParameterDecl3095);
5624            variableModifiers();
5625
5626            state._fsp--;
5627            if (state.failed) return ;
5628            dbg.location(683,9);
5629            pushFollow(FOLLOW_type_in_ellipsisParameterDecl3105);
5630            type();
5631
5632            state._fsp--;
5633            if (state.failed) return ;
5634            dbg.location(683,15);
5635            match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_ellipsisParameterDecl3108); if (state.failed) return ;
5636            dbg.location(684,9);
5637            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_ellipsisParameterDecl3118); if (state.failed) return ;
5638
5639            }
5640
5641        }
5642        catch (RecognitionException re) {
5643            reportError(re);
5644            recover(input,re);
5645        }
5646        finally {
5647            if ( state.backtracking>0 ) { memoize(input, 41, ellipsisParameterDecl_StartIndex); }
5648        }
5649        dbg.location(685, 5);
5650
5651        }
5652        finally {
5653            dbg.exitRule(getGrammarFileName(), "ellipsisParameterDecl");
5654            decRuleLevel();
5655            if ( getRuleLevel()==0 ) {dbg.terminate();}
5656        }
5657
5658        return ;
5659    }
5660    // $ANTLR end "ellipsisParameterDecl"
5661
5662
5663    // $ANTLR start "explicitConstructorInvocation"
5664    // src/com/google/doclava/parser/Java.g:688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' );
5665    public final void explicitConstructorInvocation() throws RecognitionException {
5666        int explicitConstructorInvocation_StartIndex = input.index();
5667        try { dbg.enterRule(getGrammarFileName(), "explicitConstructorInvocation");
5668        if ( getRuleLevel()==0 ) {dbg.commence();}
5669        incRuleLevel();
5670        dbg.location(688, 1);
5671
5672        try {
5673            if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return ; }
5674            // src/com/google/doclava/parser/Java.g:689:5: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' )
5675            int alt76=2;
5676            try { dbg.enterDecision(76, decisionCanBacktrack[76]);
5677
5678            try {
5679                isCyclicDecision = true;
5680                alt76 = dfa76.predict(input);
5681            }
5682            catch (NoViableAltException nvae) {
5683                dbg.recognitionException(nvae);
5684                throw nvae;
5685            }
5686            } finally {dbg.exitDecision(76);}
5687
5688            switch (alt76) {
5689                case 1 :
5690                    dbg.enterAlt(1);
5691
5692                    // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';'
5693                    {
5694                    dbg.location(689,9);
5695                    // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )?
5696                    int alt74=2;
5697                    try { dbg.enterSubRule(74);
5698                    try { dbg.enterDecision(74, decisionCanBacktrack[74]);
5699
5700                    int LA74_0 = input.LA(1);
5701
5702                    if ( (LA74_0==LT) ) {
5703                        alt74=1;
5704                    }
5705                    } finally {dbg.exitDecision(74);}
5706
5707                    switch (alt74) {
5708                        case 1 :
5709                            dbg.enterAlt(1);
5710
5711                            // src/com/google/doclava/parser/Java.g:689:10: nonWildcardTypeArguments
5712                            {
5713                            dbg.location(689,10);
5714                            pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3139);
5715                            nonWildcardTypeArguments();
5716
5717                            state._fsp--;
5718                            if (state.failed) return ;
5719
5720                            }
5721                            break;
5722
5723                    }
5724                    } finally {dbg.exitSubRule(74);}
5725
5726                    dbg.location(691,9);
5727                    if ( input.LA(1)==SUPER||input.LA(1)==THIS ) {
5728                        input.consume();
5729                        state.errorRecovery=false;state.failed=false;
5730                    }
5731                    else {
5732                        if (state.backtracking>0) {state.failed=true; return ;}
5733                        MismatchedSetException mse = new MismatchedSetException(null,input);
5734                        dbg.recognitionException(mse);
5735                        throw mse;
5736                    }
5737
5738                    dbg.location(694,9);
5739                    pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3197);
5740                    arguments();
5741
5742                    state._fsp--;
5743                    if (state.failed) return ;
5744                    dbg.location(694,19);
5745                    match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3199); if (state.failed) return ;
5746
5747                    }
5748                    break;
5749                case 2 :
5750                    dbg.enterAlt(2);
5751
5752                    // src/com/google/doclava/parser/Java.g:696:9: primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';'
5753                    {
5754                    dbg.location(696,9);
5755                    pushFollow(FOLLOW_primary_in_explicitConstructorInvocation3210);
5756                    primary();
5757
5758                    state._fsp--;
5759                    if (state.failed) return ;
5760                    dbg.location(697,9);
5761                    match(input,DOT,FOLLOW_DOT_in_explicitConstructorInvocation3220); if (state.failed) return ;
5762                    dbg.location(698,9);
5763                    // src/com/google/doclava/parser/Java.g:698:9: ( nonWildcardTypeArguments )?
5764                    int alt75=2;
5765                    try { dbg.enterSubRule(75);
5766                    try { dbg.enterDecision(75, decisionCanBacktrack[75]);
5767
5768                    int LA75_0 = input.LA(1);
5769
5770                    if ( (LA75_0==LT) ) {
5771                        alt75=1;
5772                    }
5773                    } finally {dbg.exitDecision(75);}
5774
5775                    switch (alt75) {
5776                        case 1 :
5777                            dbg.enterAlt(1);
5778
5779                            // src/com/google/doclava/parser/Java.g:698:10: nonWildcardTypeArguments
5780                            {
5781                            dbg.location(698,10);
5782                            pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation3231);
5783                            nonWildcardTypeArguments();
5784
5785                            state._fsp--;
5786                            if (state.failed) return ;
5787
5788                            }
5789                            break;
5790
5791                    }
5792                    } finally {dbg.exitSubRule(75);}
5793
5794                    dbg.location(700,9);
5795                    match(input,SUPER,FOLLOW_SUPER_in_explicitConstructorInvocation3252); if (state.failed) return ;
5796                    dbg.location(701,9);
5797                    pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation3262);
5798                    arguments();
5799
5800                    state._fsp--;
5801                    if (state.failed) return ;
5802                    dbg.location(701,19);
5803                    match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation3264); if (state.failed) return ;
5804
5805                    }
5806                    break;
5807
5808            }
5809        }
5810        catch (RecognitionException re) {
5811            reportError(re);
5812            recover(input,re);
5813        }
5814        finally {
5815            if ( state.backtracking>0 ) { memoize(input, 42, explicitConstructorInvocation_StartIndex); }
5816        }
5817        dbg.location(702, 5);
5818
5819        }
5820        finally {
5821            dbg.exitRule(getGrammarFileName(), "explicitConstructorInvocation");
5822            decRuleLevel();
5823            if ( getRuleLevel()==0 ) {dbg.terminate();}
5824        }
5825
5826        return ;
5827    }
5828    // $ANTLR end "explicitConstructorInvocation"
5829
5830
5831    // $ANTLR start "qualifiedName"
5832    // src/com/google/doclava/parser/Java.g:704:1: qualifiedName : IDENTIFIER ( '.' IDENTIFIER )* ;
5833    public final void qualifiedName() throws RecognitionException {
5834        int qualifiedName_StartIndex = input.index();
5835        try { dbg.enterRule(getGrammarFileName(), "qualifiedName");
5836        if ( getRuleLevel()==0 ) {dbg.commence();}
5837        incRuleLevel();
5838        dbg.location(704, 1);
5839
5840        try {
5841            if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return ; }
5842            // src/com/google/doclava/parser/Java.g:705:5: ( IDENTIFIER ( '.' IDENTIFIER )* )
5843            dbg.enterAlt(1);
5844
5845            // src/com/google/doclava/parser/Java.g:705:9: IDENTIFIER ( '.' IDENTIFIER )*
5846            {
5847            dbg.location(705,9);
5848            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3283); if (state.failed) return ;
5849            dbg.location(706,9);
5850            // src/com/google/doclava/parser/Java.g:706:9: ( '.' IDENTIFIER )*
5851            try { dbg.enterSubRule(77);
5852
5853            loop77:
5854            do {
5855                int alt77=2;
5856                try { dbg.enterDecision(77, decisionCanBacktrack[77]);
5857
5858                int LA77_0 = input.LA(1);
5859
5860                if ( (LA77_0==DOT) ) {
5861                    alt77=1;
5862                }
5863
5864
5865                } finally {dbg.exitDecision(77);}
5866
5867                switch (alt77) {
5868		case 1 :
5869		    dbg.enterAlt(1);
5870
5871		    // src/com/google/doclava/parser/Java.g:706:10: '.' IDENTIFIER
5872		    {
5873		    dbg.location(706,10);
5874		    match(input,DOT,FOLLOW_DOT_in_qualifiedName3294); if (state.failed) return ;
5875		    dbg.location(706,14);
5876		    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName3296); if (state.failed) return ;
5877
5878		    }
5879		    break;
5880
5881		default :
5882		    break loop77;
5883                }
5884            } while (true);
5885            } finally {dbg.exitSubRule(77);}
5886
5887
5888            }
5889
5890        }
5891        catch (RecognitionException re) {
5892            reportError(re);
5893            recover(input,re);
5894        }
5895        finally {
5896            if ( state.backtracking>0 ) { memoize(input, 43, qualifiedName_StartIndex); }
5897        }
5898        dbg.location(708, 5);
5899
5900        }
5901        finally {
5902            dbg.exitRule(getGrammarFileName(), "qualifiedName");
5903            decRuleLevel();
5904            if ( getRuleLevel()==0 ) {dbg.terminate();}
5905        }
5906
5907        return ;
5908    }
5909    // $ANTLR end "qualifiedName"
5910
5911
5912    // $ANTLR start "annotations"
5913    // src/com/google/doclava/parser/Java.g:710:1: annotations : ( annotation )+ ;
5914    public final void annotations() throws RecognitionException {
5915        int annotations_StartIndex = input.index();
5916        try { dbg.enterRule(getGrammarFileName(), "annotations");
5917        if ( getRuleLevel()==0 ) {dbg.commence();}
5918        incRuleLevel();
5919        dbg.location(710, 1);
5920
5921        try {
5922            if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return ; }
5923            // src/com/google/doclava/parser/Java.g:711:5: ( ( annotation )+ )
5924            dbg.enterAlt(1);
5925
5926            // src/com/google/doclava/parser/Java.g:711:9: ( annotation )+
5927            {
5928            dbg.location(711,9);
5929            // src/com/google/doclava/parser/Java.g:711:9: ( annotation )+
5930            int cnt78=0;
5931            try { dbg.enterSubRule(78);
5932
5933            loop78:
5934            do {
5935                int alt78=2;
5936                try { dbg.enterDecision(78, decisionCanBacktrack[78]);
5937
5938                int LA78_0 = input.LA(1);
5939
5940                if ( (LA78_0==MONKEYS_AT) ) {
5941                    alt78=1;
5942                }
5943
5944
5945                } finally {dbg.exitDecision(78);}
5946
5947                switch (alt78) {
5948		case 1 :
5949		    dbg.enterAlt(1);
5950
5951		    // src/com/google/doclava/parser/Java.g:711:10: annotation
5952		    {
5953		    dbg.location(711,10);
5954		    pushFollow(FOLLOW_annotation_in_annotations3327);
5955		    annotation();
5956
5957		    state._fsp--;
5958		    if (state.failed) return ;
5959
5960		    }
5961		    break;
5962
5963		default :
5964		    if ( cnt78 >= 1 ) break loop78;
5965		    if (state.backtracking>0) {state.failed=true; return ;}
5966                        EarlyExitException eee =
5967                            new EarlyExitException(78, input);
5968                        dbg.recognitionException(eee);
5969
5970                        throw eee;
5971                }
5972                cnt78++;
5973            } while (true);
5974            } finally {dbg.exitSubRule(78);}
5975
5976
5977            }
5978
5979        }
5980        catch (RecognitionException re) {
5981            reportError(re);
5982            recover(input,re);
5983        }
5984        finally {
5985            if ( state.backtracking>0 ) { memoize(input, 44, annotations_StartIndex); }
5986        }
5987        dbg.location(713, 5);
5988
5989        }
5990        finally {
5991            dbg.exitRule(getGrammarFileName(), "annotations");
5992            decRuleLevel();
5993            if ( getRuleLevel()==0 ) {dbg.terminate();}
5994        }
5995
5996        return ;
5997    }
5998    // $ANTLR end "annotations"
5999
6000
6001    // $ANTLR start "annotation"
6002    // src/com/google/doclava/parser/Java.g:715:1: annotation : '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? ;
6003    public final void annotation() throws RecognitionException {
6004        int annotation_StartIndex = input.index();
6005        try { dbg.enterRule(getGrammarFileName(), "annotation");
6006        if ( getRuleLevel()==0 ) {dbg.commence();}
6007        incRuleLevel();
6008        dbg.location(715, 1);
6009
6010        try {
6011            if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return ; }
6012            // src/com/google/doclava/parser/Java.g:720:5: ( '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? )
6013            dbg.enterAlt(1);
6014
6015            // src/com/google/doclava/parser/Java.g:720:9: '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )?
6016            {
6017            dbg.location(720,9);
6018            match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotation3359); if (state.failed) return ;
6019            dbg.location(720,13);
6020            pushFollow(FOLLOW_qualifiedName_in_annotation3361);
6021            qualifiedName();
6022
6023            state._fsp--;
6024            if (state.failed) return ;
6025            dbg.location(721,9);
6026            // src/com/google/doclava/parser/Java.g:721:9: ( '(' ( elementValuePairs | elementValue )? ')' )?
6027            int alt80=2;
6028            try { dbg.enterSubRule(80);
6029            try { dbg.enterDecision(80, decisionCanBacktrack[80]);
6030
6031            int LA80_0 = input.LA(1);
6032
6033            if ( (LA80_0==LPAREN) ) {
6034                alt80=1;
6035            }
6036            } finally {dbg.exitDecision(80);}
6037
6038            switch (alt80) {
6039                case 1 :
6040                    dbg.enterAlt(1);
6041
6042                    // src/com/google/doclava/parser/Java.g:721:13: '(' ( elementValuePairs | elementValue )? ')'
6043                    {
6044                    dbg.location(721,13);
6045                    match(input,LPAREN,FOLLOW_LPAREN_in_annotation3375); if (state.failed) return ;
6046                    dbg.location(722,19);
6047                    // src/com/google/doclava/parser/Java.g:722:19: ( elementValuePairs | elementValue )?
6048                    int alt79=3;
6049                    try { dbg.enterSubRule(79);
6050                    try { dbg.enterDecision(79, decisionCanBacktrack[79]);
6051
6052                    int LA79_0 = input.LA(1);
6053
6054                    if ( (LA79_0==IDENTIFIER) ) {
6055                        int LA79_1 = input.LA(2);
6056
6057                        if ( (LA79_1==EQ) ) {
6058                            alt79=1;
6059                        }
6060                        else if ( (LA79_1==INSTANCEOF||(LA79_1>=LPAREN && LA79_1<=RPAREN)||LA79_1==LBRACKET||LA79_1==DOT||LA79_1==QUES||(LA79_1>=EQEQ && LA79_1<=PERCENT)||(LA79_1>=BANGEQ && LA79_1<=LT)) ) {
6061                            alt79=2;
6062                        }
6063                    }
6064                    else if ( ((LA79_0>=INTLITERAL && LA79_0<=NULL)||LA79_0==BOOLEAN||LA79_0==BYTE||LA79_0==CHAR||LA79_0==DOUBLE||LA79_0==FLOAT||LA79_0==INT||LA79_0==LONG||LA79_0==NEW||LA79_0==SHORT||LA79_0==SUPER||LA79_0==THIS||LA79_0==VOID||LA79_0==LPAREN||LA79_0==LBRACE||(LA79_0>=BANG && LA79_0<=TILDE)||(LA79_0>=PLUSPLUS && LA79_0<=SUB)||LA79_0==MONKEYS_AT) ) {
6065                        alt79=2;
6066                    }
6067                    } finally {dbg.exitDecision(79);}
6068
6069                    switch (alt79) {
6070                        case 1 :
6071                            dbg.enterAlt(1);
6072
6073                            // src/com/google/doclava/parser/Java.g:722:23: elementValuePairs
6074                            {
6075                            dbg.location(722,23);
6076                            pushFollow(FOLLOW_elementValuePairs_in_annotation3399);
6077                            elementValuePairs();
6078
6079                            state._fsp--;
6080                            if (state.failed) return ;
6081
6082                            }
6083                            break;
6084                        case 2 :
6085                            dbg.enterAlt(2);
6086
6087                            // src/com/google/doclava/parser/Java.g:723:23: elementValue
6088                            {
6089                            dbg.location(723,23);
6090                            pushFollow(FOLLOW_elementValue_in_annotation3423);
6091                            elementValue();
6092
6093                            state._fsp--;
6094                            if (state.failed) return ;
6095
6096                            }
6097                            break;
6098
6099                    }
6100                    } finally {dbg.exitSubRule(79);}
6101
6102                    dbg.location(725,13);
6103                    match(input,RPAREN,FOLLOW_RPAREN_in_annotation3458); if (state.failed) return ;
6104
6105                    }
6106                    break;
6107
6108            }
6109            } finally {dbg.exitSubRule(80);}
6110
6111
6112            }
6113
6114        }
6115        catch (RecognitionException re) {
6116            reportError(re);
6117            recover(input,re);
6118        }
6119        finally {
6120            if ( state.backtracking>0 ) { memoize(input, 45, annotation_StartIndex); }
6121        }
6122        dbg.location(727, 5);
6123
6124        }
6125        finally {
6126            dbg.exitRule(getGrammarFileName(), "annotation");
6127            decRuleLevel();
6128            if ( getRuleLevel()==0 ) {dbg.terminate();}
6129        }
6130
6131        return ;
6132    }
6133    // $ANTLR end "annotation"
6134
6135
6136    // $ANTLR start "elementValuePairs"
6137    // src/com/google/doclava/parser/Java.g:729:1: elementValuePairs : elementValuePair ( ',' elementValuePair )* ;
6138    public final void elementValuePairs() throws RecognitionException {
6139        int elementValuePairs_StartIndex = input.index();
6140        try { dbg.enterRule(getGrammarFileName(), "elementValuePairs");
6141        if ( getRuleLevel()==0 ) {dbg.commence();}
6142        incRuleLevel();
6143        dbg.location(729, 1);
6144
6145        try {
6146            if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return ; }
6147            // src/com/google/doclava/parser/Java.g:730:5: ( elementValuePair ( ',' elementValuePair )* )
6148            dbg.enterAlt(1);
6149
6150            // src/com/google/doclava/parser/Java.g:730:9: elementValuePair ( ',' elementValuePair )*
6151            {
6152            dbg.location(730,9);
6153            pushFollow(FOLLOW_elementValuePair_in_elementValuePairs3488);
6154            elementValuePair();
6155
6156            state._fsp--;
6157            if (state.failed) return ;
6158            dbg.location(731,9);
6159            // src/com/google/doclava/parser/Java.g:731:9: ( ',' elementValuePair )*
6160            try { dbg.enterSubRule(81);
6161
6162            loop81:
6163            do {
6164                int alt81=2;
6165                try { dbg.enterDecision(81, decisionCanBacktrack[81]);
6166
6167                int LA81_0 = input.LA(1);
6168
6169                if ( (LA81_0==COMMA) ) {
6170                    alt81=1;
6171                }
6172
6173
6174                } finally {dbg.exitDecision(81);}
6175
6176                switch (alt81) {
6177		case 1 :
6178		    dbg.enterAlt(1);
6179
6180		    // src/com/google/doclava/parser/Java.g:731:10: ',' elementValuePair
6181		    {
6182		    dbg.location(731,10);
6183		    match(input,COMMA,FOLLOW_COMMA_in_elementValuePairs3499); if (state.failed) return ;
6184		    dbg.location(731,14);
6185		    pushFollow(FOLLOW_elementValuePair_in_elementValuePairs3501);
6186		    elementValuePair();
6187
6188		    state._fsp--;
6189		    if (state.failed) return ;
6190
6191		    }
6192		    break;
6193
6194		default :
6195		    break loop81;
6196                }
6197            } while (true);
6198            } finally {dbg.exitSubRule(81);}
6199
6200
6201            }
6202
6203        }
6204        catch (RecognitionException re) {
6205            reportError(re);
6206            recover(input,re);
6207        }
6208        finally {
6209            if ( state.backtracking>0 ) { memoize(input, 46, elementValuePairs_StartIndex); }
6210        }
6211        dbg.location(733, 5);
6212
6213        }
6214        finally {
6215            dbg.exitRule(getGrammarFileName(), "elementValuePairs");
6216            decRuleLevel();
6217            if ( getRuleLevel()==0 ) {dbg.terminate();}
6218        }
6219
6220        return ;
6221    }
6222    // $ANTLR end "elementValuePairs"
6223
6224
6225    // $ANTLR start "elementValuePair"
6226    // src/com/google/doclava/parser/Java.g:735:1: elementValuePair : IDENTIFIER '=' elementValue ;
6227    public final void elementValuePair() throws RecognitionException {
6228        int elementValuePair_StartIndex = input.index();
6229        try { dbg.enterRule(getGrammarFileName(), "elementValuePair");
6230        if ( getRuleLevel()==0 ) {dbg.commence();}
6231        incRuleLevel();
6232        dbg.location(735, 1);
6233
6234        try {
6235            if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return ; }
6236            // src/com/google/doclava/parser/Java.g:736:5: ( IDENTIFIER '=' elementValue )
6237            dbg.enterAlt(1);
6238
6239            // src/com/google/doclava/parser/Java.g:736:9: IDENTIFIER '=' elementValue
6240            {
6241            dbg.location(736,9);
6242            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_elementValuePair3531); if (state.failed) return ;
6243            dbg.location(736,20);
6244            match(input,EQ,FOLLOW_EQ_in_elementValuePair3533); if (state.failed) return ;
6245            dbg.location(736,24);
6246            pushFollow(FOLLOW_elementValue_in_elementValuePair3535);
6247            elementValue();
6248
6249            state._fsp--;
6250            if (state.failed) return ;
6251
6252            }
6253
6254        }
6255        catch (RecognitionException re) {
6256            reportError(re);
6257            recover(input,re);
6258        }
6259        finally {
6260            if ( state.backtracking>0 ) { memoize(input, 47, elementValuePair_StartIndex); }
6261        }
6262        dbg.location(737, 5);
6263
6264        }
6265        finally {
6266            dbg.exitRule(getGrammarFileName(), "elementValuePair");
6267            decRuleLevel();
6268            if ( getRuleLevel()==0 ) {dbg.terminate();}
6269        }
6270
6271        return ;
6272    }
6273    // $ANTLR end "elementValuePair"
6274
6275
6276    // $ANTLR start "elementValue"
6277    // src/com/google/doclava/parser/Java.g:739:1: elementValue : ( conditionalExpression | annotation | elementValueArrayInitializer );
6278    public final void elementValue() throws RecognitionException {
6279        int elementValue_StartIndex = input.index();
6280        try { dbg.enterRule(getGrammarFileName(), "elementValue");
6281        if ( getRuleLevel()==0 ) {dbg.commence();}
6282        incRuleLevel();
6283        dbg.location(739, 1);
6284
6285        try {
6286            if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return ; }
6287            // src/com/google/doclava/parser/Java.g:740:5: ( conditionalExpression | annotation | elementValueArrayInitializer )
6288            int alt82=3;
6289            try { dbg.enterDecision(82, decisionCanBacktrack[82]);
6290
6291            switch ( input.LA(1) ) {
6292            case IDENTIFIER:
6293            case INTLITERAL:
6294            case LONGLITERAL:
6295            case FLOATLITERAL:
6296            case DOUBLELITERAL:
6297            case CHARLITERAL:
6298            case STRINGLITERAL:
6299            case TRUE:
6300            case FALSE:
6301            case NULL:
6302            case BOOLEAN:
6303            case BYTE:
6304            case CHAR:
6305            case DOUBLE:
6306            case FLOAT:
6307            case INT:
6308            case LONG:
6309            case NEW:
6310            case SHORT:
6311            case SUPER:
6312            case THIS:
6313            case VOID:
6314            case LPAREN:
6315            case BANG:
6316            case TILDE:
6317            case PLUSPLUS:
6318            case SUBSUB:
6319            case PLUS:
6320            case SUB:
6321                {
6322                alt82=1;
6323                }
6324                break;
6325            case MONKEYS_AT:
6326                {
6327                alt82=2;
6328                }
6329                break;
6330            case LBRACE:
6331                {
6332                alt82=3;
6333                }
6334                break;
6335            default:
6336                if (state.backtracking>0) {state.failed=true; return ;}
6337                NoViableAltException nvae =
6338                    new NoViableAltException("", 82, 0, input);
6339
6340                dbg.recognitionException(nvae);
6341                throw nvae;
6342            }
6343
6344            } finally {dbg.exitDecision(82);}
6345
6346            switch (alt82) {
6347                case 1 :
6348                    dbg.enterAlt(1);
6349
6350                    // src/com/google/doclava/parser/Java.g:740:9: conditionalExpression
6351                    {
6352                    dbg.location(740,9);
6353                    pushFollow(FOLLOW_conditionalExpression_in_elementValue3554);
6354                    conditionalExpression();
6355
6356                    state._fsp--;
6357                    if (state.failed) return ;
6358
6359                    }
6360                    break;
6361                case 2 :
6362                    dbg.enterAlt(2);
6363
6364                    // src/com/google/doclava/parser/Java.g:741:9: annotation
6365                    {
6366                    dbg.location(741,9);
6367                    pushFollow(FOLLOW_annotation_in_elementValue3564);
6368                    annotation();
6369
6370                    state._fsp--;
6371                    if (state.failed) return ;
6372
6373                    }
6374                    break;
6375                case 3 :
6376                    dbg.enterAlt(3);
6377
6378                    // src/com/google/doclava/parser/Java.g:742:9: elementValueArrayInitializer
6379                    {
6380                    dbg.location(742,9);
6381                    pushFollow(FOLLOW_elementValueArrayInitializer_in_elementValue3574);
6382                    elementValueArrayInitializer();
6383
6384                    state._fsp--;
6385                    if (state.failed) return ;
6386
6387                    }
6388                    break;
6389
6390            }
6391        }
6392        catch (RecognitionException re) {
6393            reportError(re);
6394            recover(input,re);
6395        }
6396        finally {
6397            if ( state.backtracking>0 ) { memoize(input, 48, elementValue_StartIndex); }
6398        }
6399        dbg.location(743, 5);
6400
6401        }
6402        finally {
6403            dbg.exitRule(getGrammarFileName(), "elementValue");
6404            decRuleLevel();
6405            if ( getRuleLevel()==0 ) {dbg.terminate();}
6406        }
6407
6408        return ;
6409    }
6410    // $ANTLR end "elementValue"
6411
6412
6413    // $ANTLR start "elementValueArrayInitializer"
6414    // src/com/google/doclava/parser/Java.g:745:1: elementValueArrayInitializer : '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' ;
6415    public final void elementValueArrayInitializer() throws RecognitionException {
6416        int elementValueArrayInitializer_StartIndex = input.index();
6417        try { dbg.enterRule(getGrammarFileName(), "elementValueArrayInitializer");
6418        if ( getRuleLevel()==0 ) {dbg.commence();}
6419        incRuleLevel();
6420        dbg.location(745, 1);
6421
6422        try {
6423            if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return ; }
6424            // src/com/google/doclava/parser/Java.g:746:5: ( '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' )
6425            dbg.enterAlt(1);
6426
6427            // src/com/google/doclava/parser/Java.g:746:9: '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}'
6428            {
6429            dbg.location(746,9);
6430            match(input,LBRACE,FOLLOW_LBRACE_in_elementValueArrayInitializer3593); if (state.failed) return ;
6431            dbg.location(747,9);
6432            // src/com/google/doclava/parser/Java.g:747:9: ( elementValue ( ',' elementValue )* )?
6433            int alt84=2;
6434            try { dbg.enterSubRule(84);
6435            try { dbg.enterDecision(84, decisionCanBacktrack[84]);
6436
6437            int LA84_0 = input.LA(1);
6438
6439            if ( ((LA84_0>=IDENTIFIER && LA84_0<=NULL)||LA84_0==BOOLEAN||LA84_0==BYTE||LA84_0==CHAR||LA84_0==DOUBLE||LA84_0==FLOAT||LA84_0==INT||LA84_0==LONG||LA84_0==NEW||LA84_0==SHORT||LA84_0==SUPER||LA84_0==THIS||LA84_0==VOID||LA84_0==LPAREN||LA84_0==LBRACE||(LA84_0>=BANG && LA84_0<=TILDE)||(LA84_0>=PLUSPLUS && LA84_0<=SUB)||LA84_0==MONKEYS_AT) ) {
6440                alt84=1;
6441            }
6442            } finally {dbg.exitDecision(84);}
6443
6444            switch (alt84) {
6445                case 1 :
6446                    dbg.enterAlt(1);
6447
6448                    // src/com/google/doclava/parser/Java.g:747:10: elementValue ( ',' elementValue )*
6449                    {
6450                    dbg.location(747,10);
6451                    pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer3604);
6452                    elementValue();
6453
6454                    state._fsp--;
6455                    if (state.failed) return ;
6456                    dbg.location(748,13);
6457                    // src/com/google/doclava/parser/Java.g:748:13: ( ',' elementValue )*
6458                    try { dbg.enterSubRule(83);
6459
6460                    loop83:
6461                    do {
6462                        int alt83=2;
6463                        try { dbg.enterDecision(83, decisionCanBacktrack[83]);
6464
6465                        int LA83_0 = input.LA(1);
6466
6467                        if ( (LA83_0==COMMA) ) {
6468                            int LA83_1 = input.LA(2);
6469
6470                            if ( ((LA83_1>=IDENTIFIER && LA83_1<=NULL)||LA83_1==BOOLEAN||LA83_1==BYTE||LA83_1==CHAR||LA83_1==DOUBLE||LA83_1==FLOAT||LA83_1==INT||LA83_1==LONG||LA83_1==NEW||LA83_1==SHORT||LA83_1==SUPER||LA83_1==THIS||LA83_1==VOID||LA83_1==LPAREN||LA83_1==LBRACE||(LA83_1>=BANG && LA83_1<=TILDE)||(LA83_1>=PLUSPLUS && LA83_1<=SUB)||LA83_1==MONKEYS_AT) ) {
6471                                alt83=1;
6472                            }
6473
6474
6475                        }
6476
6477
6478                        } finally {dbg.exitDecision(83);}
6479
6480                        switch (alt83) {
6481			case 1 :
6482			    dbg.enterAlt(1);
6483
6484			    // src/com/google/doclava/parser/Java.g:748:14: ',' elementValue
6485			    {
6486			    dbg.location(748,14);
6487			    match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer3619); if (state.failed) return ;
6488			    dbg.location(748,18);
6489			    pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer3621);
6490			    elementValue();
6491
6492			    state._fsp--;
6493			    if (state.failed) return ;
6494
6495			    }
6496			    break;
6497
6498			default :
6499			    break loop83;
6500                        }
6501                    } while (true);
6502                    } finally {dbg.exitSubRule(83);}
6503
6504
6505                    }
6506                    break;
6507
6508            }
6509            } finally {dbg.exitSubRule(84);}
6510
6511            dbg.location(750,12);
6512            // src/com/google/doclava/parser/Java.g:750:12: ( ',' )?
6513            int alt85=2;
6514            try { dbg.enterSubRule(85);
6515            try { dbg.enterDecision(85, decisionCanBacktrack[85]);
6516
6517            int LA85_0 = input.LA(1);
6518
6519            if ( (LA85_0==COMMA) ) {
6520                alt85=1;
6521            }
6522            } finally {dbg.exitDecision(85);}
6523
6524            switch (alt85) {
6525                case 1 :
6526                    dbg.enterAlt(1);
6527
6528                    // src/com/google/doclava/parser/Java.g:750:13: ','
6529                    {
6530                    dbg.location(750,13);
6531                    match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer3650); if (state.failed) return ;
6532
6533                    }
6534                    break;
6535
6536            }
6537            } finally {dbg.exitSubRule(85);}
6538
6539            dbg.location(750,19);
6540            match(input,RBRACE,FOLLOW_RBRACE_in_elementValueArrayInitializer3654); if (state.failed) return ;
6541
6542            }
6543
6544        }
6545        catch (RecognitionException re) {
6546            reportError(re);
6547            recover(input,re);
6548        }
6549        finally {
6550            if ( state.backtracking>0 ) { memoize(input, 49, elementValueArrayInitializer_StartIndex); }
6551        }
6552        dbg.location(751, 5);
6553
6554        }
6555        finally {
6556            dbg.exitRule(getGrammarFileName(), "elementValueArrayInitializer");
6557            decRuleLevel();
6558            if ( getRuleLevel()==0 ) {dbg.terminate();}
6559        }
6560
6561        return ;
6562    }
6563    // $ANTLR end "elementValueArrayInitializer"
6564
6565
6566    // $ANTLR start "annotationTypeDeclaration"
6567    // src/com/google/doclava/parser/Java.g:754:1: annotationTypeDeclaration : modifiers '@' 'interface' IDENTIFIER annotationTypeBody ;
6568    public final void annotationTypeDeclaration() throws RecognitionException {
6569        int annotationTypeDeclaration_StartIndex = input.index();
6570        try { dbg.enterRule(getGrammarFileName(), "annotationTypeDeclaration");
6571        if ( getRuleLevel()==0 ) {dbg.commence();}
6572        incRuleLevel();
6573        dbg.location(754, 1);
6574
6575        try {
6576            if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return ; }
6577            // src/com/google/doclava/parser/Java.g:758:5: ( modifiers '@' 'interface' IDENTIFIER annotationTypeBody )
6578            dbg.enterAlt(1);
6579
6580            // src/com/google/doclava/parser/Java.g:758:9: modifiers '@' 'interface' IDENTIFIER annotationTypeBody
6581            {
6582            dbg.location(758,9);
6583            pushFollow(FOLLOW_modifiers_in_annotationTypeDeclaration3676);
6584            modifiers();
6585
6586            state._fsp--;
6587            if (state.failed) return ;
6588            dbg.location(758,19);
6589            match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration3678); if (state.failed) return ;
6590            dbg.location(759,9);
6591            match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationTypeDeclaration3688); if (state.failed) return ;
6592            dbg.location(760,9);
6593            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationTypeDeclaration3698); if (state.failed) return ;
6594            dbg.location(761,9);
6595            pushFollow(FOLLOW_annotationTypeBody_in_annotationTypeDeclaration3708);
6596            annotationTypeBody();
6597
6598            state._fsp--;
6599            if (state.failed) return ;
6600
6601            }
6602
6603        }
6604        catch (RecognitionException re) {
6605            reportError(re);
6606            recover(input,re);
6607        }
6608        finally {
6609            if ( state.backtracking>0 ) { memoize(input, 50, annotationTypeDeclaration_StartIndex); }
6610        }
6611        dbg.location(762, 5);
6612
6613        }
6614        finally {
6615            dbg.exitRule(getGrammarFileName(), "annotationTypeDeclaration");
6616            decRuleLevel();
6617            if ( getRuleLevel()==0 ) {dbg.terminate();}
6618        }
6619
6620        return ;
6621    }
6622    // $ANTLR end "annotationTypeDeclaration"
6623
6624
6625    // $ANTLR start "annotationTypeBody"
6626    // src/com/google/doclava/parser/Java.g:765:1: annotationTypeBody : '{' ( annotationTypeElementDeclaration )* '}' ;
6627    public final void annotationTypeBody() throws RecognitionException {
6628        int annotationTypeBody_StartIndex = input.index();
6629        try { dbg.enterRule(getGrammarFileName(), "annotationTypeBody");
6630        if ( getRuleLevel()==0 ) {dbg.commence();}
6631        incRuleLevel();
6632        dbg.location(765, 1);
6633
6634        try {
6635            if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return ; }
6636            // src/com/google/doclava/parser/Java.g:766:5: ( '{' ( annotationTypeElementDeclaration )* '}' )
6637            dbg.enterAlt(1);
6638
6639            // src/com/google/doclava/parser/Java.g:766:9: '{' ( annotationTypeElementDeclaration )* '}'
6640            {
6641            dbg.location(766,9);
6642            match(input,LBRACE,FOLLOW_LBRACE_in_annotationTypeBody3728); if (state.failed) return ;
6643            dbg.location(767,9);
6644            // src/com/google/doclava/parser/Java.g:767:9: ( annotationTypeElementDeclaration )*
6645            try { dbg.enterSubRule(86);
6646
6647            loop86:
6648            do {
6649                int alt86=2;
6650                try { dbg.enterDecision(86, decisionCanBacktrack[86]);
6651
6652                int LA86_0 = input.LA(1);
6653
6654                if ( (LA86_0==IDENTIFIER||LA86_0==ABSTRACT||LA86_0==BOOLEAN||LA86_0==BYTE||(LA86_0>=CHAR && LA86_0<=CLASS)||LA86_0==DOUBLE||LA86_0==ENUM||LA86_0==FINAL||LA86_0==FLOAT||(LA86_0>=INT && LA86_0<=NATIVE)||(LA86_0>=PRIVATE && LA86_0<=PUBLIC)||(LA86_0>=SHORT && LA86_0<=STRICTFP)||LA86_0==SYNCHRONIZED||LA86_0==TRANSIENT||(LA86_0>=VOID && LA86_0<=VOLATILE)||LA86_0==SEMI||LA86_0==MONKEYS_AT||LA86_0==LT) ) {
6655                    alt86=1;
6656                }
6657
6658
6659                } finally {dbg.exitDecision(86);}
6660
6661                switch (alt86) {
6662		case 1 :
6663		    dbg.enterAlt(1);
6664
6665		    // src/com/google/doclava/parser/Java.g:767:10: annotationTypeElementDeclaration
6666		    {
6667		    dbg.location(767,10);
6668		    pushFollow(FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody3739);
6669		    annotationTypeElementDeclaration();
6670
6671		    state._fsp--;
6672		    if (state.failed) return ;
6673
6674		    }
6675		    break;
6676
6677		default :
6678		    break loop86;
6679                }
6680            } while (true);
6681            } finally {dbg.exitSubRule(86);}
6682
6683            dbg.location(769,9);
6684            match(input,RBRACE,FOLLOW_RBRACE_in_annotationTypeBody3760); if (state.failed) return ;
6685
6686            }
6687
6688        }
6689        catch (RecognitionException re) {
6690            reportError(re);
6691            recover(input,re);
6692        }
6693        finally {
6694            if ( state.backtracking>0 ) { memoize(input, 51, annotationTypeBody_StartIndex); }
6695        }
6696        dbg.location(770, 5);
6697
6698        }
6699        finally {
6700            dbg.exitRule(getGrammarFileName(), "annotationTypeBody");
6701            decRuleLevel();
6702            if ( getRuleLevel()==0 ) {dbg.terminate();}
6703        }
6704
6705        return ;
6706    }
6707    // $ANTLR end "annotationTypeBody"
6708
6709
6710    // $ANTLR start "annotationTypeElementDeclaration"
6711    // src/com/google/doclava/parser/Java.g:772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' );
6712    public final void annotationTypeElementDeclaration() throws RecognitionException {
6713        int annotationTypeElementDeclaration_StartIndex = input.index();
6714        try { dbg.enterRule(getGrammarFileName(), "annotationTypeElementDeclaration");
6715        if ( getRuleLevel()==0 ) {dbg.commence();}
6716        incRuleLevel();
6717        dbg.location(772, 1);
6718
6719        try {
6720            if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return ; }
6721            // src/com/google/doclava/parser/Java.g:776:5: ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' )
6722            int alt87=7;
6723            try { dbg.enterDecision(87, decisionCanBacktrack[87]);
6724
6725            try {
6726                isCyclicDecision = true;
6727                alt87 = dfa87.predict(input);
6728            }
6729            catch (NoViableAltException nvae) {
6730                dbg.recognitionException(nvae);
6731                throw nvae;
6732            }
6733            } finally {dbg.exitDecision(87);}
6734
6735            switch (alt87) {
6736                case 1 :
6737                    dbg.enterAlt(1);
6738
6739                    // src/com/google/doclava/parser/Java.g:776:9: annotationMethodDeclaration
6740                    {
6741                    dbg.location(776,9);
6742                    pushFollow(FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration3781);
6743                    annotationMethodDeclaration();
6744
6745                    state._fsp--;
6746                    if (state.failed) return ;
6747
6748                    }
6749                    break;
6750                case 2 :
6751                    dbg.enterAlt(2);
6752
6753                    // src/com/google/doclava/parser/Java.g:777:9: interfaceFieldDeclaration
6754                    {
6755                    dbg.location(777,9);
6756                    pushFollow(FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration3791);
6757                    interfaceFieldDeclaration();
6758
6759                    state._fsp--;
6760                    if (state.failed) return ;
6761
6762                    }
6763                    break;
6764                case 3 :
6765                    dbg.enterAlt(3);
6766
6767                    // src/com/google/doclava/parser/Java.g:778:9: normalClassDeclaration
6768                    {
6769                    dbg.location(778,9);
6770                    pushFollow(FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration3801);
6771                    normalClassDeclaration();
6772
6773                    state._fsp--;
6774                    if (state.failed) return ;
6775
6776                    }
6777                    break;
6778                case 4 :
6779                    dbg.enterAlt(4);
6780
6781                    // src/com/google/doclava/parser/Java.g:779:9: normalInterfaceDeclaration
6782                    {
6783                    dbg.location(779,9);
6784                    pushFollow(FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration3811);
6785                    normalInterfaceDeclaration();
6786
6787                    state._fsp--;
6788                    if (state.failed) return ;
6789
6790                    }
6791                    break;
6792                case 5 :
6793                    dbg.enterAlt(5);
6794
6795                    // src/com/google/doclava/parser/Java.g:780:9: enumDeclaration
6796                    {
6797                    dbg.location(780,9);
6798                    pushFollow(FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration3821);
6799                    enumDeclaration();
6800
6801                    state._fsp--;
6802                    if (state.failed) return ;
6803
6804                    }
6805                    break;
6806                case 6 :
6807                    dbg.enterAlt(6);
6808
6809                    // src/com/google/doclava/parser/Java.g:781:9: annotationTypeDeclaration
6810                    {
6811                    dbg.location(781,9);
6812                    pushFollow(FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration3831);
6813                    annotationTypeDeclaration();
6814
6815                    state._fsp--;
6816                    if (state.failed) return ;
6817
6818                    }
6819                    break;
6820                case 7 :
6821                    dbg.enterAlt(7);
6822
6823                    // src/com/google/doclava/parser/Java.g:782:9: ';'
6824                    {
6825                    dbg.location(782,9);
6826                    match(input,SEMI,FOLLOW_SEMI_in_annotationTypeElementDeclaration3841); if (state.failed) return ;
6827
6828                    }
6829                    break;
6830
6831            }
6832        }
6833        catch (RecognitionException re) {
6834            reportError(re);
6835            recover(input,re);
6836        }
6837        finally {
6838            if ( state.backtracking>0 ) { memoize(input, 52, annotationTypeElementDeclaration_StartIndex); }
6839        }
6840        dbg.location(783, 5);
6841
6842        }
6843        finally {
6844            dbg.exitRule(getGrammarFileName(), "annotationTypeElementDeclaration");
6845            decRuleLevel();
6846            if ( getRuleLevel()==0 ) {dbg.terminate();}
6847        }
6848
6849        return ;
6850    }
6851    // $ANTLR end "annotationTypeElementDeclaration"
6852
6853
6854    // $ANTLR start "annotationMethodDeclaration"
6855    // src/com/google/doclava/parser/Java.g:785:1: annotationMethodDeclaration : modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' ;
6856    public final void annotationMethodDeclaration() throws RecognitionException {
6857        int annotationMethodDeclaration_StartIndex = input.index();
6858        try { dbg.enterRule(getGrammarFileName(), "annotationMethodDeclaration");
6859        if ( getRuleLevel()==0 ) {dbg.commence();}
6860        incRuleLevel();
6861        dbg.location(785, 1);
6862
6863        try {
6864            if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return ; }
6865            // src/com/google/doclava/parser/Java.g:786:5: ( modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' )
6866            dbg.enterAlt(1);
6867
6868            // src/com/google/doclava/parser/Java.g:786:9: modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';'
6869            {
6870            dbg.location(786,9);
6871            pushFollow(FOLLOW_modifiers_in_annotationMethodDeclaration3860);
6872            modifiers();
6873
6874            state._fsp--;
6875            if (state.failed) return ;
6876            dbg.location(786,19);
6877            pushFollow(FOLLOW_type_in_annotationMethodDeclaration3862);
6878            type();
6879
6880            state._fsp--;
6881            if (state.failed) return ;
6882            dbg.location(786,24);
6883            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationMethodDeclaration3864); if (state.failed) return ;
6884            dbg.location(787,9);
6885            match(input,LPAREN,FOLLOW_LPAREN_in_annotationMethodDeclaration3874); if (state.failed) return ;
6886            dbg.location(787,13);
6887            match(input,RPAREN,FOLLOW_RPAREN_in_annotationMethodDeclaration3876); if (state.failed) return ;
6888            dbg.location(787,17);
6889            // src/com/google/doclava/parser/Java.g:787:17: ( 'default' elementValue )?
6890            int alt88=2;
6891            try { dbg.enterSubRule(88);
6892            try { dbg.enterDecision(88, decisionCanBacktrack[88]);
6893
6894            int LA88_0 = input.LA(1);
6895
6896            if ( (LA88_0==DEFAULT) ) {
6897                alt88=1;
6898            }
6899            } finally {dbg.exitDecision(88);}
6900
6901            switch (alt88) {
6902                case 1 :
6903                    dbg.enterAlt(1);
6904
6905                    // src/com/google/doclava/parser/Java.g:787:18: 'default' elementValue
6906                    {
6907                    dbg.location(787,18);
6908                    match(input,DEFAULT,FOLLOW_DEFAULT_in_annotationMethodDeclaration3879); if (state.failed) return ;
6909                    dbg.location(787,28);
6910                    pushFollow(FOLLOW_elementValue_in_annotationMethodDeclaration3881);
6911                    elementValue();
6912
6913                    state._fsp--;
6914                    if (state.failed) return ;
6915
6916                    }
6917                    break;
6918
6919            }
6920            } finally {dbg.exitSubRule(88);}
6921
6922            dbg.location(789,9);
6923            match(input,SEMI,FOLLOW_SEMI_in_annotationMethodDeclaration3910); if (state.failed) return ;
6924
6925            }
6926
6927        }
6928        catch (RecognitionException re) {
6929            reportError(re);
6930            recover(input,re);
6931        }
6932        finally {
6933            if ( state.backtracking>0 ) { memoize(input, 53, annotationMethodDeclaration_StartIndex); }
6934        }
6935        dbg.location(790, 9);
6936
6937        }
6938        finally {
6939            dbg.exitRule(getGrammarFileName(), "annotationMethodDeclaration");
6940            decRuleLevel();
6941            if ( getRuleLevel()==0 ) {dbg.terminate();}
6942        }
6943
6944        return ;
6945    }
6946    // $ANTLR end "annotationMethodDeclaration"
6947
6948
6949    // $ANTLR start "block"
6950    // src/com/google/doclava/parser/Java.g:792:1: block : '{' ( blockStatement )* '}' ;
6951    public final void block() throws RecognitionException {
6952        int block_StartIndex = input.index();
6953        try { dbg.enterRule(getGrammarFileName(), "block");
6954        if ( getRuleLevel()==0 ) {dbg.commence();}
6955        incRuleLevel();
6956        dbg.location(792, 1);
6957
6958        try {
6959            if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return ; }
6960            // src/com/google/doclava/parser/Java.g:793:5: ( '{' ( blockStatement )* '}' )
6961            dbg.enterAlt(1);
6962
6963            // src/com/google/doclava/parser/Java.g:793:9: '{' ( blockStatement )* '}'
6964            {
6965            dbg.location(793,9);
6966            match(input,LBRACE,FOLLOW_LBRACE_in_block3933); if (state.failed) return ;
6967            dbg.location(794,9);
6968            // src/com/google/doclava/parser/Java.g:794:9: ( blockStatement )*
6969            try { dbg.enterSubRule(89);
6970
6971            loop89:
6972            do {
6973                int alt89=2;
6974                try { dbg.enterDecision(89, decisionCanBacktrack[89]);
6975
6976                int LA89_0 = input.LA(1);
6977
6978                if ( ((LA89_0>=IDENTIFIER && LA89_0<=NULL)||(LA89_0>=ABSTRACT && LA89_0<=BYTE)||(LA89_0>=CHAR && LA89_0<=CLASS)||LA89_0==CONTINUE||(LA89_0>=DO && LA89_0<=DOUBLE)||LA89_0==ENUM||LA89_0==FINAL||(LA89_0>=FLOAT && LA89_0<=FOR)||LA89_0==IF||(LA89_0>=INT && LA89_0<=NEW)||(LA89_0>=PRIVATE && LA89_0<=THROW)||(LA89_0>=TRANSIENT && LA89_0<=LPAREN)||LA89_0==LBRACE||LA89_0==SEMI||(LA89_0>=BANG && LA89_0<=TILDE)||(LA89_0>=PLUSPLUS && LA89_0<=SUB)||LA89_0==MONKEYS_AT||LA89_0==LT) ) {
6979                    alt89=1;
6980                }
6981
6982
6983                } finally {dbg.exitDecision(89);}
6984
6985                switch (alt89) {
6986		case 1 :
6987		    dbg.enterAlt(1);
6988
6989		    // src/com/google/doclava/parser/Java.g:794:10: blockStatement
6990		    {
6991		    dbg.location(794,10);
6992		    pushFollow(FOLLOW_blockStatement_in_block3944);
6993		    blockStatement();
6994
6995		    state._fsp--;
6996		    if (state.failed) return ;
6997
6998		    }
6999		    break;
7000
7001		default :
7002		    break loop89;
7003                }
7004            } while (true);
7005            } finally {dbg.exitSubRule(89);}
7006
7007            dbg.location(796,9);
7008            match(input,RBRACE,FOLLOW_RBRACE_in_block3965); if (state.failed) return ;
7009
7010            }
7011
7012        }
7013        catch (RecognitionException re) {
7014            reportError(re);
7015            recover(input,re);
7016        }
7017        finally {
7018            if ( state.backtracking>0 ) { memoize(input, 54, block_StartIndex); }
7019        }
7020        dbg.location(797, 5);
7021
7022        }
7023        finally {
7024            dbg.exitRule(getGrammarFileName(), "block");
7025            decRuleLevel();
7026            if ( getRuleLevel()==0 ) {dbg.terminate();}
7027        }
7028
7029        return ;
7030    }
7031    // $ANTLR end "block"
7032
7033
7034    // $ANTLR start "blockStatement"
7035    // src/com/google/doclava/parser/Java.g:823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );
7036    public final void blockStatement() throws RecognitionException {
7037        int blockStatement_StartIndex = input.index();
7038        try { dbg.enterRule(getGrammarFileName(), "blockStatement");
7039        if ( getRuleLevel()==0 ) {dbg.commence();}
7040        incRuleLevel();
7041        dbg.location(823, 1);
7042
7043        try {
7044            if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return ; }
7045            // src/com/google/doclava/parser/Java.g:824:5: ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement )
7046            int alt90=3;
7047            try { dbg.enterDecision(90, decisionCanBacktrack[90]);
7048
7049            try {
7050                isCyclicDecision = true;
7051                alt90 = dfa90.predict(input);
7052            }
7053            catch (NoViableAltException nvae) {
7054                dbg.recognitionException(nvae);
7055                throw nvae;
7056            }
7057            } finally {dbg.exitDecision(90);}
7058
7059            switch (alt90) {
7060                case 1 :
7061                    dbg.enterAlt(1);
7062
7063                    // src/com/google/doclava/parser/Java.g:824:9: localVariableDeclarationStatement
7064                    {
7065                    dbg.location(824,9);
7066                    pushFollow(FOLLOW_localVariableDeclarationStatement_in_blockStatement3986);
7067                    localVariableDeclarationStatement();
7068
7069                    state._fsp--;
7070                    if (state.failed) return ;
7071
7072                    }
7073                    break;
7074                case 2 :
7075                    dbg.enterAlt(2);
7076
7077                    // src/com/google/doclava/parser/Java.g:825:9: classOrInterfaceDeclaration
7078                    {
7079                    dbg.location(825,9);
7080                    pushFollow(FOLLOW_classOrInterfaceDeclaration_in_blockStatement3996);
7081                    classOrInterfaceDeclaration();
7082
7083                    state._fsp--;
7084                    if (state.failed) return ;
7085
7086                    }
7087                    break;
7088                case 3 :
7089                    dbg.enterAlt(3);
7090
7091                    // src/com/google/doclava/parser/Java.g:826:9: statement
7092                    {
7093                    dbg.location(826,9);
7094                    pushFollow(FOLLOW_statement_in_blockStatement4006);
7095                    statement();
7096
7097                    state._fsp--;
7098                    if (state.failed) return ;
7099
7100                    }
7101                    break;
7102
7103            }
7104        }
7105        catch (RecognitionException re) {
7106            reportError(re);
7107            recover(input,re);
7108        }
7109        finally {
7110            if ( state.backtracking>0 ) { memoize(input, 55, blockStatement_StartIndex); }
7111        }
7112        dbg.location(827, 5);
7113
7114        }
7115        finally {
7116            dbg.exitRule(getGrammarFileName(), "blockStatement");
7117            decRuleLevel();
7118            if ( getRuleLevel()==0 ) {dbg.terminate();}
7119        }
7120
7121        return ;
7122    }
7123    // $ANTLR end "blockStatement"
7124
7125
7126    // $ANTLR start "localVariableDeclarationStatement"
7127    // src/com/google/doclava/parser/Java.g:830:1: localVariableDeclarationStatement : localVariableDeclaration ';' ;
7128    public final void localVariableDeclarationStatement() throws RecognitionException {
7129        int localVariableDeclarationStatement_StartIndex = input.index();
7130        try { dbg.enterRule(getGrammarFileName(), "localVariableDeclarationStatement");
7131        if ( getRuleLevel()==0 ) {dbg.commence();}
7132        incRuleLevel();
7133        dbg.location(830, 1);
7134
7135        try {
7136            if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return ; }
7137            // src/com/google/doclava/parser/Java.g:831:5: ( localVariableDeclaration ';' )
7138            dbg.enterAlt(1);
7139
7140            // src/com/google/doclava/parser/Java.g:831:9: localVariableDeclaration ';'
7141            {
7142            dbg.location(831,9);
7143            pushFollow(FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement4026);
7144            localVariableDeclaration();
7145
7146            state._fsp--;
7147            if (state.failed) return ;
7148            dbg.location(832,9);
7149            match(input,SEMI,FOLLOW_SEMI_in_localVariableDeclarationStatement4036); if (state.failed) return ;
7150
7151            }
7152
7153        }
7154        catch (RecognitionException re) {
7155            reportError(re);
7156            recover(input,re);
7157        }
7158        finally {
7159            if ( state.backtracking>0 ) { memoize(input, 56, localVariableDeclarationStatement_StartIndex); }
7160        }
7161        dbg.location(833, 5);
7162
7163        }
7164        finally {
7165            dbg.exitRule(getGrammarFileName(), "localVariableDeclarationStatement");
7166            decRuleLevel();
7167            if ( getRuleLevel()==0 ) {dbg.terminate();}
7168        }
7169
7170        return ;
7171    }
7172    // $ANTLR end "localVariableDeclarationStatement"
7173
7174
7175    // $ANTLR start "localVariableDeclaration"
7176    // src/com/google/doclava/parser/Java.g:835:1: localVariableDeclaration : variableModifiers type variableDeclarator ( ',' variableDeclarator )* ;
7177    public final void localVariableDeclaration() throws RecognitionException {
7178        int localVariableDeclaration_StartIndex = input.index();
7179        try { dbg.enterRule(getGrammarFileName(), "localVariableDeclaration");
7180        if ( getRuleLevel()==0 ) {dbg.commence();}
7181        incRuleLevel();
7182        dbg.location(835, 1);
7183
7184        try {
7185            if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return ; }
7186            // src/com/google/doclava/parser/Java.g:836:5: ( variableModifiers type variableDeclarator ( ',' variableDeclarator )* )
7187            dbg.enterAlt(1);
7188
7189            // src/com/google/doclava/parser/Java.g:836:9: variableModifiers type variableDeclarator ( ',' variableDeclarator )*
7190            {
7191            dbg.location(836,9);
7192            pushFollow(FOLLOW_variableModifiers_in_localVariableDeclaration4055);
7193            variableModifiers();
7194
7195            state._fsp--;
7196            if (state.failed) return ;
7197            dbg.location(836,27);
7198            pushFollow(FOLLOW_type_in_localVariableDeclaration4057);
7199            type();
7200
7201            state._fsp--;
7202            if (state.failed) return ;
7203            dbg.location(837,9);
7204            pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4067);
7205            variableDeclarator();
7206
7207            state._fsp--;
7208            if (state.failed) return ;
7209            dbg.location(838,9);
7210            // src/com/google/doclava/parser/Java.g:838:9: ( ',' variableDeclarator )*
7211            try { dbg.enterSubRule(91);
7212
7213            loop91:
7214            do {
7215                int alt91=2;
7216                try { dbg.enterDecision(91, decisionCanBacktrack[91]);
7217
7218                int LA91_0 = input.LA(1);
7219
7220                if ( (LA91_0==COMMA) ) {
7221                    alt91=1;
7222                }
7223
7224
7225                } finally {dbg.exitDecision(91);}
7226
7227                switch (alt91) {
7228		case 1 :
7229		    dbg.enterAlt(1);
7230
7231		    // src/com/google/doclava/parser/Java.g:838:10: ',' variableDeclarator
7232		    {
7233		    dbg.location(838,10);
7234		    match(input,COMMA,FOLLOW_COMMA_in_localVariableDeclaration4078); if (state.failed) return ;
7235		    dbg.location(838,14);
7236		    pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration4080);
7237		    variableDeclarator();
7238
7239		    state._fsp--;
7240		    if (state.failed) return ;
7241
7242		    }
7243		    break;
7244
7245		default :
7246		    break loop91;
7247                }
7248            } while (true);
7249            } finally {dbg.exitSubRule(91);}
7250
7251
7252            }
7253
7254        }
7255        catch (RecognitionException re) {
7256            reportError(re);
7257            recover(input,re);
7258        }
7259        finally {
7260            if ( state.backtracking>0 ) { memoize(input, 57, localVariableDeclaration_StartIndex); }
7261        }
7262        dbg.location(840, 5);
7263
7264        }
7265        finally {
7266            dbg.exitRule(getGrammarFileName(), "localVariableDeclaration");
7267            decRuleLevel();
7268            if ( getRuleLevel()==0 ) {dbg.terminate();}
7269        }
7270
7271        return ;
7272    }
7273    // $ANTLR end "localVariableDeclaration"
7274
7275
7276    // $ANTLR start "statement"
7277    // src/com/google/doclava/parser/Java.g:842:1: statement : ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' );
7278    public final void statement() throws RecognitionException {
7279        int statement_StartIndex = input.index();
7280        try { dbg.enterRule(getGrammarFileName(), "statement");
7281        if ( getRuleLevel()==0 ) {dbg.commence();}
7282        incRuleLevel();
7283        dbg.location(842, 1);
7284
7285        try {
7286            if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return ; }
7287            // src/com/google/doclava/parser/Java.g:843:5: ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' )
7288            int alt98=17;
7289            try { dbg.enterDecision(98, decisionCanBacktrack[98]);
7290
7291            try {
7292                isCyclicDecision = true;
7293                alt98 = dfa98.predict(input);
7294            }
7295            catch (NoViableAltException nvae) {
7296                dbg.recognitionException(nvae);
7297                throw nvae;
7298            }
7299            } finally {dbg.exitDecision(98);}
7300
7301            switch (alt98) {
7302                case 1 :
7303                    dbg.enterAlt(1);
7304
7305                    // src/com/google/doclava/parser/Java.g:843:9: block
7306                    {
7307                    dbg.location(843,9);
7308                    pushFollow(FOLLOW_block_in_statement4110);
7309                    block();
7310
7311                    state._fsp--;
7312                    if (state.failed) return ;
7313
7314                    }
7315                    break;
7316                case 2 :
7317                    dbg.enterAlt(2);
7318
7319                    // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) expression ( ':' expression )? ';'
7320                    {
7321                    dbg.location(845,9);
7322                    // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' )
7323                    dbg.enterAlt(1);
7324
7325                    // src/com/google/doclava/parser/Java.g:845:10: 'assert'
7326                    {
7327                    dbg.location(845,10);
7328                    match(input,ASSERT,FOLLOW_ASSERT_in_statement4122); if (state.failed) return ;
7329
7330                    }
7331
7332                    dbg.location(847,9);
7333                    pushFollow(FOLLOW_expression_in_statement4142);
7334                    expression();
7335
7336                    state._fsp--;
7337                    if (state.failed) return ;
7338                    dbg.location(847,20);
7339                    // src/com/google/doclava/parser/Java.g:847:20: ( ':' expression )?
7340                    int alt92=2;
7341                    try { dbg.enterSubRule(92);
7342                    try { dbg.enterDecision(92, decisionCanBacktrack[92]);
7343
7344                    int LA92_0 = input.LA(1);
7345
7346                    if ( (LA92_0==COLON) ) {
7347                        alt92=1;
7348                    }
7349                    } finally {dbg.exitDecision(92);}
7350
7351                    switch (alt92) {
7352                        case 1 :
7353                            dbg.enterAlt(1);
7354
7355                            // src/com/google/doclava/parser/Java.g:847:21: ':' expression
7356                            {
7357                            dbg.location(847,21);
7358                            match(input,COLON,FOLLOW_COLON_in_statement4145); if (state.failed) return ;
7359                            dbg.location(847,25);
7360                            pushFollow(FOLLOW_expression_in_statement4147);
7361                            expression();
7362
7363                            state._fsp--;
7364                            if (state.failed) return ;
7365
7366                            }
7367                            break;
7368
7369                    }
7370                    } finally {dbg.exitSubRule(92);}
7371
7372                    dbg.location(847,38);
7373                    match(input,SEMI,FOLLOW_SEMI_in_statement4151); if (state.failed) return ;
7374
7375                    }
7376                    break;
7377                case 3 :
7378                    dbg.enterAlt(3);
7379
7380                    // src/com/google/doclava/parser/Java.g:848:9: 'assert' expression ( ':' expression )? ';'
7381                    {
7382                    dbg.location(848,9);
7383                    match(input,ASSERT,FOLLOW_ASSERT_in_statement4161); if (state.failed) return ;
7384                    dbg.location(848,19);
7385                    pushFollow(FOLLOW_expression_in_statement4164);
7386                    expression();
7387
7388                    state._fsp--;
7389                    if (state.failed) return ;
7390                    dbg.location(848,30);
7391                    // src/com/google/doclava/parser/Java.g:848:30: ( ':' expression )?
7392                    int alt93=2;
7393                    try { dbg.enterSubRule(93);
7394                    try { dbg.enterDecision(93, decisionCanBacktrack[93]);
7395
7396                    int LA93_0 = input.LA(1);
7397
7398                    if ( (LA93_0==COLON) ) {
7399                        alt93=1;
7400                    }
7401                    } finally {dbg.exitDecision(93);}
7402
7403                    switch (alt93) {
7404                        case 1 :
7405                            dbg.enterAlt(1);
7406
7407                            // src/com/google/doclava/parser/Java.g:848:31: ':' expression
7408                            {
7409                            dbg.location(848,31);
7410                            match(input,COLON,FOLLOW_COLON_in_statement4167); if (state.failed) return ;
7411                            dbg.location(848,35);
7412                            pushFollow(FOLLOW_expression_in_statement4169);
7413                            expression();
7414
7415                            state._fsp--;
7416                            if (state.failed) return ;
7417
7418                            }
7419                            break;
7420
7421                    }
7422                    } finally {dbg.exitSubRule(93);}
7423
7424                    dbg.location(848,48);
7425                    match(input,SEMI,FOLLOW_SEMI_in_statement4173); if (state.failed) return ;
7426
7427                    }
7428                    break;
7429                case 4 :
7430                    dbg.enterAlt(4);
7431
7432                    // src/com/google/doclava/parser/Java.g:849:9: 'if' parExpression statement ( 'else' statement )?
7433                    {
7434                    dbg.location(849,9);
7435                    match(input,IF,FOLLOW_IF_in_statement4183); if (state.failed) return ;
7436                    dbg.location(849,14);
7437                    pushFollow(FOLLOW_parExpression_in_statement4185);
7438                    parExpression();
7439
7440                    state._fsp--;
7441                    if (state.failed) return ;
7442                    dbg.location(849,28);
7443                    pushFollow(FOLLOW_statement_in_statement4187);
7444                    statement();
7445
7446                    state._fsp--;
7447                    if (state.failed) return ;
7448                    dbg.location(849,38);
7449                    // src/com/google/doclava/parser/Java.g:849:38: ( 'else' statement )?
7450                    int alt94=2;
7451                    try { dbg.enterSubRule(94);
7452                    try { dbg.enterDecision(94, decisionCanBacktrack[94]);
7453
7454                    int LA94_0 = input.LA(1);
7455
7456                    if ( (LA94_0==ELSE) ) {
7457                        int LA94_1 = input.LA(2);
7458
7459                        if ( (synpred133_Java()) ) {
7460                            alt94=1;
7461                        }
7462                    }
7463                    } finally {dbg.exitDecision(94);}
7464
7465                    switch (alt94) {
7466                        case 1 :
7467                            dbg.enterAlt(1);
7468
7469                            // src/com/google/doclava/parser/Java.g:849:39: 'else' statement
7470                            {
7471                            dbg.location(849,39);
7472                            match(input,ELSE,FOLLOW_ELSE_in_statement4190); if (state.failed) return ;
7473                            dbg.location(849,46);
7474                            pushFollow(FOLLOW_statement_in_statement4192);
7475                            statement();
7476
7477                            state._fsp--;
7478                            if (state.failed) return ;
7479
7480                            }
7481                            break;
7482
7483                    }
7484                    } finally {dbg.exitSubRule(94);}
7485
7486
7487                    }
7488                    break;
7489                case 5 :
7490                    dbg.enterAlt(5);
7491
7492                    // src/com/google/doclava/parser/Java.g:850:9: forstatement
7493                    {
7494                    dbg.location(850,9);
7495                    pushFollow(FOLLOW_forstatement_in_statement4204);
7496                    forstatement();
7497
7498                    state._fsp--;
7499                    if (state.failed) return ;
7500
7501                    }
7502                    break;
7503                case 6 :
7504                    dbg.enterAlt(6);
7505
7506                    // src/com/google/doclava/parser/Java.g:851:9: 'while' parExpression statement
7507                    {
7508                    dbg.location(851,9);
7509                    match(input,WHILE,FOLLOW_WHILE_in_statement4214); if (state.failed) return ;
7510                    dbg.location(851,17);
7511                    pushFollow(FOLLOW_parExpression_in_statement4216);
7512                    parExpression();
7513
7514                    state._fsp--;
7515                    if (state.failed) return ;
7516                    dbg.location(851,31);
7517                    pushFollow(FOLLOW_statement_in_statement4218);
7518                    statement();
7519
7520                    state._fsp--;
7521                    if (state.failed) return ;
7522
7523                    }
7524                    break;
7525                case 7 :
7526                    dbg.enterAlt(7);
7527
7528                    // src/com/google/doclava/parser/Java.g:852:9: 'do' statement 'while' parExpression ';'
7529                    {
7530                    dbg.location(852,9);
7531                    match(input,DO,FOLLOW_DO_in_statement4228); if (state.failed) return ;
7532                    dbg.location(852,14);
7533                    pushFollow(FOLLOW_statement_in_statement4230);
7534                    statement();
7535
7536                    state._fsp--;
7537                    if (state.failed) return ;
7538                    dbg.location(852,24);
7539                    match(input,WHILE,FOLLOW_WHILE_in_statement4232); if (state.failed) return ;
7540                    dbg.location(852,32);
7541                    pushFollow(FOLLOW_parExpression_in_statement4234);
7542                    parExpression();
7543
7544                    state._fsp--;
7545                    if (state.failed) return ;
7546                    dbg.location(852,46);
7547                    match(input,SEMI,FOLLOW_SEMI_in_statement4236); if (state.failed) return ;
7548
7549                    }
7550                    break;
7551                case 8 :
7552                    dbg.enterAlt(8);
7553
7554                    // src/com/google/doclava/parser/Java.g:853:9: trystatement
7555                    {
7556                    dbg.location(853,9);
7557                    pushFollow(FOLLOW_trystatement_in_statement4246);
7558                    trystatement();
7559
7560                    state._fsp--;
7561                    if (state.failed) return ;
7562
7563                    }
7564                    break;
7565                case 9 :
7566                    dbg.enterAlt(9);
7567
7568                    // src/com/google/doclava/parser/Java.g:854:9: 'switch' parExpression '{' switchBlockStatementGroups '}'
7569                    {
7570                    dbg.location(854,9);
7571                    match(input,SWITCH,FOLLOW_SWITCH_in_statement4256); if (state.failed) return ;
7572                    dbg.location(854,18);
7573                    pushFollow(FOLLOW_parExpression_in_statement4258);
7574                    parExpression();
7575
7576                    state._fsp--;
7577                    if (state.failed) return ;
7578                    dbg.location(854,32);
7579                    match(input,LBRACE,FOLLOW_LBRACE_in_statement4260); if (state.failed) return ;
7580                    dbg.location(854,36);
7581                    pushFollow(FOLLOW_switchBlockStatementGroups_in_statement4262);
7582                    switchBlockStatementGroups();
7583
7584                    state._fsp--;
7585                    if (state.failed) return ;
7586                    dbg.location(854,63);
7587                    match(input,RBRACE,FOLLOW_RBRACE_in_statement4264); if (state.failed) return ;
7588
7589                    }
7590                    break;
7591                case 10 :
7592                    dbg.enterAlt(10);
7593
7594                    // src/com/google/doclava/parser/Java.g:855:9: 'synchronized' parExpression block
7595                    {
7596                    dbg.location(855,9);
7597                    match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_statement4274); if (state.failed) return ;
7598                    dbg.location(855,24);
7599                    pushFollow(FOLLOW_parExpression_in_statement4276);
7600                    parExpression();
7601
7602                    state._fsp--;
7603                    if (state.failed) return ;
7604                    dbg.location(855,38);
7605                    pushFollow(FOLLOW_block_in_statement4278);
7606                    block();
7607
7608                    state._fsp--;
7609                    if (state.failed) return ;
7610
7611                    }
7612                    break;
7613                case 11 :
7614                    dbg.enterAlt(11);
7615
7616                    // src/com/google/doclava/parser/Java.g:856:9: 'return' ( expression )? ';'
7617                    {
7618                    dbg.location(856,9);
7619                    match(input,RETURN,FOLLOW_RETURN_in_statement4288); if (state.failed) return ;
7620                    dbg.location(856,18);
7621                    // src/com/google/doclava/parser/Java.g:856:18: ( expression )?
7622                    int alt95=2;
7623                    try { dbg.enterSubRule(95);
7624                    try { dbg.enterDecision(95, decisionCanBacktrack[95]);
7625
7626                    int LA95_0 = input.LA(1);
7627
7628                    if ( ((LA95_0>=IDENTIFIER && LA95_0<=NULL)||LA95_0==BOOLEAN||LA95_0==BYTE||LA95_0==CHAR||LA95_0==DOUBLE||LA95_0==FLOAT||LA95_0==INT||LA95_0==LONG||LA95_0==NEW||LA95_0==SHORT||LA95_0==SUPER||LA95_0==THIS||LA95_0==VOID||LA95_0==LPAREN||(LA95_0>=BANG && LA95_0<=TILDE)||(LA95_0>=PLUSPLUS && LA95_0<=SUB)) ) {
7629                        alt95=1;
7630                    }
7631                    } finally {dbg.exitDecision(95);}
7632
7633                    switch (alt95) {
7634                        case 1 :
7635                            dbg.enterAlt(1);
7636
7637                            // src/com/google/doclava/parser/Java.g:856:19: expression
7638                            {
7639                            dbg.location(856,19);
7640                            pushFollow(FOLLOW_expression_in_statement4291);
7641                            expression();
7642
7643                            state._fsp--;
7644                            if (state.failed) return ;
7645
7646                            }
7647                            break;
7648
7649                    }
7650                    } finally {dbg.exitSubRule(95);}
7651
7652                    dbg.location(856,33);
7653                    match(input,SEMI,FOLLOW_SEMI_in_statement4296); if (state.failed) return ;
7654
7655                    }
7656                    break;
7657                case 12 :
7658                    dbg.enterAlt(12);
7659
7660                    // src/com/google/doclava/parser/Java.g:857:9: 'throw' expression ';'
7661                    {
7662                    dbg.location(857,9);
7663                    match(input,THROW,FOLLOW_THROW_in_statement4306); if (state.failed) return ;
7664                    dbg.location(857,17);
7665                    pushFollow(FOLLOW_expression_in_statement4308);
7666                    expression();
7667
7668                    state._fsp--;
7669                    if (state.failed) return ;
7670                    dbg.location(857,28);
7671                    match(input,SEMI,FOLLOW_SEMI_in_statement4310); if (state.failed) return ;
7672
7673                    }
7674                    break;
7675                case 13 :
7676                    dbg.enterAlt(13);
7677
7678                    // src/com/google/doclava/parser/Java.g:858:9: 'break' ( IDENTIFIER )? ';'
7679                    {
7680                    dbg.location(858,9);
7681                    match(input,BREAK,FOLLOW_BREAK_in_statement4320); if (state.failed) return ;
7682                    dbg.location(859,13);
7683                    // src/com/google/doclava/parser/Java.g:859:13: ( IDENTIFIER )?
7684                    int alt96=2;
7685                    try { dbg.enterSubRule(96);
7686                    try { dbg.enterDecision(96, decisionCanBacktrack[96]);
7687
7688                    int LA96_0 = input.LA(1);
7689
7690                    if ( (LA96_0==IDENTIFIER) ) {
7691                        alt96=1;
7692                    }
7693                    } finally {dbg.exitDecision(96);}
7694
7695                    switch (alt96) {
7696                        case 1 :
7697                            dbg.enterAlt(1);
7698
7699                            // src/com/google/doclava/parser/Java.g:859:14: IDENTIFIER
7700                            {
7701                            dbg.location(859,14);
7702                            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4335); if (state.failed) return ;
7703
7704                            }
7705                            break;
7706
7707                    }
7708                    } finally {dbg.exitSubRule(96);}
7709
7710                    dbg.location(860,16);
7711                    match(input,SEMI,FOLLOW_SEMI_in_statement4352); if (state.failed) return ;
7712
7713                    }
7714                    break;
7715                case 14 :
7716                    dbg.enterAlt(14);
7717
7718                    // src/com/google/doclava/parser/Java.g:861:9: 'continue' ( IDENTIFIER )? ';'
7719                    {
7720                    dbg.location(861,9);
7721                    match(input,CONTINUE,FOLLOW_CONTINUE_in_statement4362); if (state.failed) return ;
7722                    dbg.location(862,13);
7723                    // src/com/google/doclava/parser/Java.g:862:13: ( IDENTIFIER )?
7724                    int alt97=2;
7725                    try { dbg.enterSubRule(97);
7726                    try { dbg.enterDecision(97, decisionCanBacktrack[97]);
7727
7728                    int LA97_0 = input.LA(1);
7729
7730                    if ( (LA97_0==IDENTIFIER) ) {
7731                        alt97=1;
7732                    }
7733                    } finally {dbg.exitDecision(97);}
7734
7735                    switch (alt97) {
7736                        case 1 :
7737                            dbg.enterAlt(1);
7738
7739                            // src/com/google/doclava/parser/Java.g:862:14: IDENTIFIER
7740                            {
7741                            dbg.location(862,14);
7742                            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4377); if (state.failed) return ;
7743
7744                            }
7745                            break;
7746
7747                    }
7748                    } finally {dbg.exitSubRule(97);}
7749
7750                    dbg.location(863,16);
7751                    match(input,SEMI,FOLLOW_SEMI_in_statement4394); if (state.failed) return ;
7752
7753                    }
7754                    break;
7755                case 15 :
7756                    dbg.enterAlt(15);
7757
7758                    // src/com/google/doclava/parser/Java.g:864:9: expression ';'
7759                    {
7760                    dbg.location(864,9);
7761                    pushFollow(FOLLOW_expression_in_statement4404);
7762                    expression();
7763
7764                    state._fsp--;
7765                    if (state.failed) return ;
7766                    dbg.location(864,21);
7767                    match(input,SEMI,FOLLOW_SEMI_in_statement4407); if (state.failed) return ;
7768
7769                    }
7770                    break;
7771                case 16 :
7772                    dbg.enterAlt(16);
7773
7774                    // src/com/google/doclava/parser/Java.g:865:9: IDENTIFIER ':' statement
7775                    {
7776                    dbg.location(865,9);
7777                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement4417); if (state.failed) return ;
7778                    dbg.location(865,20);
7779                    match(input,COLON,FOLLOW_COLON_in_statement4419); if (state.failed) return ;
7780                    dbg.location(865,24);
7781                    pushFollow(FOLLOW_statement_in_statement4421);
7782                    statement();
7783
7784                    state._fsp--;
7785                    if (state.failed) return ;
7786
7787                    }
7788                    break;
7789                case 17 :
7790                    dbg.enterAlt(17);
7791
7792                    // src/com/google/doclava/parser/Java.g:866:9: ';'
7793                    {
7794                    dbg.location(866,9);
7795                    match(input,SEMI,FOLLOW_SEMI_in_statement4431); if (state.failed) return ;
7796
7797                    }
7798                    break;
7799
7800            }
7801        }
7802        catch (RecognitionException re) {
7803            reportError(re);
7804            recover(input,re);
7805        }
7806        finally {
7807            if ( state.backtracking>0 ) { memoize(input, 58, statement_StartIndex); }
7808        }
7809        dbg.location(868, 5);
7810
7811        }
7812        finally {
7813            dbg.exitRule(getGrammarFileName(), "statement");
7814            decRuleLevel();
7815            if ( getRuleLevel()==0 ) {dbg.terminate();}
7816        }
7817
7818        return ;
7819    }
7820    // $ANTLR end "statement"
7821
7822
7823    // $ANTLR start "switchBlockStatementGroups"
7824    // src/com/google/doclava/parser/Java.g:870:1: switchBlockStatementGroups : ( switchBlockStatementGroup )* ;
7825    public final void switchBlockStatementGroups() throws RecognitionException {
7826        int switchBlockStatementGroups_StartIndex = input.index();
7827        try { dbg.enterRule(getGrammarFileName(), "switchBlockStatementGroups");
7828        if ( getRuleLevel()==0 ) {dbg.commence();}
7829        incRuleLevel();
7830        dbg.location(870, 1);
7831
7832        try {
7833            if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return ; }
7834            // src/com/google/doclava/parser/Java.g:871:5: ( ( switchBlockStatementGroup )* )
7835            dbg.enterAlt(1);
7836
7837            // src/com/google/doclava/parser/Java.g:871:9: ( switchBlockStatementGroup )*
7838            {
7839            dbg.location(871,9);
7840            // src/com/google/doclava/parser/Java.g:871:9: ( switchBlockStatementGroup )*
7841            try { dbg.enterSubRule(99);
7842
7843            loop99:
7844            do {
7845                int alt99=2;
7846                try { dbg.enterDecision(99, decisionCanBacktrack[99]);
7847
7848                int LA99_0 = input.LA(1);
7849
7850                if ( (LA99_0==CASE||LA99_0==DEFAULT) ) {
7851                    alt99=1;
7852                }
7853
7854
7855                } finally {dbg.exitDecision(99);}
7856
7857                switch (alt99) {
7858		case 1 :
7859		    dbg.enterAlt(1);
7860
7861		    // src/com/google/doclava/parser/Java.g:871:10: switchBlockStatementGroup
7862		    {
7863		    dbg.location(871,10);
7864		    pushFollow(FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups4452);
7865		    switchBlockStatementGroup();
7866
7867		    state._fsp--;
7868		    if (state.failed) return ;
7869
7870		    }
7871		    break;
7872
7873		default :
7874		    break loop99;
7875                }
7876            } while (true);
7877            } finally {dbg.exitSubRule(99);}
7878
7879
7880            }
7881
7882        }
7883        catch (RecognitionException re) {
7884            reportError(re);
7885            recover(input,re);
7886        }
7887        finally {
7888            if ( state.backtracking>0 ) { memoize(input, 59, switchBlockStatementGroups_StartIndex); }
7889        }
7890        dbg.location(872, 5);
7891
7892        }
7893        finally {
7894            dbg.exitRule(getGrammarFileName(), "switchBlockStatementGroups");
7895            decRuleLevel();
7896            if ( getRuleLevel()==0 ) {dbg.terminate();}
7897        }
7898
7899        return ;
7900    }
7901    // $ANTLR end "switchBlockStatementGroups"
7902
7903
7904    // $ANTLR start "switchBlockStatementGroup"
7905    // src/com/google/doclava/parser/Java.g:874:1: switchBlockStatementGroup : switchLabel ( blockStatement )* ;
7906    public final void switchBlockStatementGroup() throws RecognitionException {
7907        int switchBlockStatementGroup_StartIndex = input.index();
7908        try { dbg.enterRule(getGrammarFileName(), "switchBlockStatementGroup");
7909        if ( getRuleLevel()==0 ) {dbg.commence();}
7910        incRuleLevel();
7911        dbg.location(874, 1);
7912
7913        try {
7914            if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return ; }
7915            // src/com/google/doclava/parser/Java.g:875:5: ( switchLabel ( blockStatement )* )
7916            dbg.enterAlt(1);
7917
7918            // src/com/google/doclava/parser/Java.g:876:9: switchLabel ( blockStatement )*
7919            {
7920            dbg.location(876,9);
7921            pushFollow(FOLLOW_switchLabel_in_switchBlockStatementGroup4480);
7922            switchLabel();
7923
7924            state._fsp--;
7925            if (state.failed) return ;
7926            dbg.location(877,9);
7927            // src/com/google/doclava/parser/Java.g:877:9: ( blockStatement )*
7928            try { dbg.enterSubRule(100);
7929
7930            loop100:
7931            do {
7932                int alt100=2;
7933                try { dbg.enterDecision(100, decisionCanBacktrack[100]);
7934
7935                int LA100_0 = input.LA(1);
7936
7937                if ( ((LA100_0>=IDENTIFIER && LA100_0<=NULL)||(LA100_0>=ABSTRACT && LA100_0<=BYTE)||(LA100_0>=CHAR && LA100_0<=CLASS)||LA100_0==CONTINUE||(LA100_0>=DO && LA100_0<=DOUBLE)||LA100_0==ENUM||LA100_0==FINAL||(LA100_0>=FLOAT && LA100_0<=FOR)||LA100_0==IF||(LA100_0>=INT && LA100_0<=NEW)||(LA100_0>=PRIVATE && LA100_0<=THROW)||(LA100_0>=TRANSIENT && LA100_0<=LPAREN)||LA100_0==LBRACE||LA100_0==SEMI||(LA100_0>=BANG && LA100_0<=TILDE)||(LA100_0>=PLUSPLUS && LA100_0<=SUB)||LA100_0==MONKEYS_AT||LA100_0==LT) ) {
7938                    alt100=1;
7939                }
7940
7941
7942                } finally {dbg.exitDecision(100);}
7943
7944                switch (alt100) {
7945		case 1 :
7946		    dbg.enterAlt(1);
7947
7948		    // src/com/google/doclava/parser/Java.g:877:10: blockStatement
7949		    {
7950		    dbg.location(877,10);
7951		    pushFollow(FOLLOW_blockStatement_in_switchBlockStatementGroup4491);
7952		    blockStatement();
7953
7954		    state._fsp--;
7955		    if (state.failed) return ;
7956
7957		    }
7958		    break;
7959
7960		default :
7961		    break loop100;
7962                }
7963            } while (true);
7964            } finally {dbg.exitSubRule(100);}
7965
7966
7967            }
7968
7969        }
7970        catch (RecognitionException re) {
7971            reportError(re);
7972            recover(input,re);
7973        }
7974        finally {
7975            if ( state.backtracking>0 ) { memoize(input, 60, switchBlockStatementGroup_StartIndex); }
7976        }
7977        dbg.location(879, 5);
7978
7979        }
7980        finally {
7981            dbg.exitRule(getGrammarFileName(), "switchBlockStatementGroup");
7982            decRuleLevel();
7983            if ( getRuleLevel()==0 ) {dbg.terminate();}
7984        }
7985
7986        return ;
7987    }
7988    // $ANTLR end "switchBlockStatementGroup"
7989
7990
7991    // $ANTLR start "switchLabel"
7992    // src/com/google/doclava/parser/Java.g:881:1: switchLabel : ( 'case' expression ':' | 'default' ':' );
7993    public final void switchLabel() throws RecognitionException {
7994        int switchLabel_StartIndex = input.index();
7995        try { dbg.enterRule(getGrammarFileName(), "switchLabel");
7996        if ( getRuleLevel()==0 ) {dbg.commence();}
7997        incRuleLevel();
7998        dbg.location(881, 1);
7999
8000        try {
8001            if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return ; }
8002            // src/com/google/doclava/parser/Java.g:882:5: ( 'case' expression ':' | 'default' ':' )
8003            int alt101=2;
8004            try { dbg.enterDecision(101, decisionCanBacktrack[101]);
8005
8006            int LA101_0 = input.LA(1);
8007
8008            if ( (LA101_0==CASE) ) {
8009                alt101=1;
8010            }
8011            else if ( (LA101_0==DEFAULT) ) {
8012                alt101=2;
8013            }
8014            else {
8015                if (state.backtracking>0) {state.failed=true; return ;}
8016                NoViableAltException nvae =
8017                    new NoViableAltException("", 101, 0, input);
8018
8019                dbg.recognitionException(nvae);
8020                throw nvae;
8021            }
8022            } finally {dbg.exitDecision(101);}
8023
8024            switch (alt101) {
8025                case 1 :
8026                    dbg.enterAlt(1);
8027
8028                    // src/com/google/doclava/parser/Java.g:882:9: 'case' expression ':'
8029                    {
8030                    dbg.location(882,9);
8031                    match(input,CASE,FOLLOW_CASE_in_switchLabel4521); if (state.failed) return ;
8032                    dbg.location(882,16);
8033                    pushFollow(FOLLOW_expression_in_switchLabel4523);
8034                    expression();
8035
8036                    state._fsp--;
8037                    if (state.failed) return ;
8038                    dbg.location(882,27);
8039                    match(input,COLON,FOLLOW_COLON_in_switchLabel4525); if (state.failed) return ;
8040
8041                    }
8042                    break;
8043                case 2 :
8044                    dbg.enterAlt(2);
8045
8046                    // src/com/google/doclava/parser/Java.g:883:9: 'default' ':'
8047                    {
8048                    dbg.location(883,9);
8049                    match(input,DEFAULT,FOLLOW_DEFAULT_in_switchLabel4535); if (state.failed) return ;
8050                    dbg.location(883,19);
8051                    match(input,COLON,FOLLOW_COLON_in_switchLabel4537); if (state.failed) return ;
8052
8053                    }
8054                    break;
8055
8056            }
8057        }
8058        catch (RecognitionException re) {
8059            reportError(re);
8060            recover(input,re);
8061        }
8062        finally {
8063            if ( state.backtracking>0 ) { memoize(input, 61, switchLabel_StartIndex); }
8064        }
8065        dbg.location(884, 5);
8066
8067        }
8068        finally {
8069            dbg.exitRule(getGrammarFileName(), "switchLabel");
8070            decRuleLevel();
8071            if ( getRuleLevel()==0 ) {dbg.terminate();}
8072        }
8073
8074        return ;
8075    }
8076    // $ANTLR end "switchLabel"
8077
8078
8079    // $ANTLR start "trystatement"
8080    // src/com/google/doclava/parser/Java.g:887:1: trystatement : 'try' block ( catches 'finally' block | catches | 'finally' block ) ;
8081    public final void trystatement() throws RecognitionException {
8082        int trystatement_StartIndex = input.index();
8083        try { dbg.enterRule(getGrammarFileName(), "trystatement");
8084        if ( getRuleLevel()==0 ) {dbg.commence();}
8085        incRuleLevel();
8086        dbg.location(887, 1);
8087
8088        try {
8089            if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return ; }
8090            // src/com/google/doclava/parser/Java.g:888:5: ( 'try' block ( catches 'finally' block | catches | 'finally' block ) )
8091            dbg.enterAlt(1);
8092
8093            // src/com/google/doclava/parser/Java.g:888:9: 'try' block ( catches 'finally' block | catches | 'finally' block )
8094            {
8095            dbg.location(888,9);
8096            match(input,TRY,FOLLOW_TRY_in_trystatement4557); if (state.failed) return ;
8097            dbg.location(888,15);
8098            pushFollow(FOLLOW_block_in_trystatement4559);
8099            block();
8100
8101            state._fsp--;
8102            if (state.failed) return ;
8103            dbg.location(889,9);
8104            // src/com/google/doclava/parser/Java.g:889:9: ( catches 'finally' block | catches | 'finally' block )
8105            int alt102=3;
8106            try { dbg.enterSubRule(102);
8107            try { dbg.enterDecision(102, decisionCanBacktrack[102]);
8108
8109            int LA102_0 = input.LA(1);
8110
8111            if ( (LA102_0==CATCH) ) {
8112                int LA102_1 = input.LA(2);
8113
8114                if ( (synpred153_Java()) ) {
8115                    alt102=1;
8116                }
8117                else if ( (synpred154_Java()) ) {
8118                    alt102=2;
8119                }
8120                else {
8121                    if (state.backtracking>0) {state.failed=true; return ;}
8122                    NoViableAltException nvae =
8123                        new NoViableAltException("", 102, 1, input);
8124
8125                    dbg.recognitionException(nvae);
8126                    throw nvae;
8127                }
8128            }
8129            else if ( (LA102_0==FINALLY) ) {
8130                alt102=3;
8131            }
8132            else {
8133                if (state.backtracking>0) {state.failed=true; return ;}
8134                NoViableAltException nvae =
8135                    new NoViableAltException("", 102, 0, input);
8136
8137                dbg.recognitionException(nvae);
8138                throw nvae;
8139            }
8140            } finally {dbg.exitDecision(102);}
8141
8142            switch (alt102) {
8143                case 1 :
8144                    dbg.enterAlt(1);
8145
8146                    // src/com/google/doclava/parser/Java.g:889:13: catches 'finally' block
8147                    {
8148                    dbg.location(889,13);
8149                    pushFollow(FOLLOW_catches_in_trystatement4573);
8150                    catches();
8151
8152                    state._fsp--;
8153                    if (state.failed) return ;
8154                    dbg.location(889,21);
8155                    match(input,FINALLY,FOLLOW_FINALLY_in_trystatement4575); if (state.failed) return ;
8156                    dbg.location(889,31);
8157                    pushFollow(FOLLOW_block_in_trystatement4577);
8158                    block();
8159
8160                    state._fsp--;
8161                    if (state.failed) return ;
8162
8163                    }
8164                    break;
8165                case 2 :
8166                    dbg.enterAlt(2);
8167
8168                    // src/com/google/doclava/parser/Java.g:890:13: catches
8169                    {
8170                    dbg.location(890,13);
8171                    pushFollow(FOLLOW_catches_in_trystatement4591);
8172                    catches();
8173
8174                    state._fsp--;
8175                    if (state.failed) return ;
8176
8177                    }
8178                    break;
8179                case 3 :
8180                    dbg.enterAlt(3);
8181
8182                    // src/com/google/doclava/parser/Java.g:891:13: 'finally' block
8183                    {
8184                    dbg.location(891,13);
8185                    match(input,FINALLY,FOLLOW_FINALLY_in_trystatement4605); if (state.failed) return ;
8186                    dbg.location(891,23);
8187                    pushFollow(FOLLOW_block_in_trystatement4607);
8188                    block();
8189
8190                    state._fsp--;
8191                    if (state.failed) return ;
8192
8193                    }
8194                    break;
8195
8196            }
8197            } finally {dbg.exitSubRule(102);}
8198
8199
8200            }
8201
8202        }
8203        catch (RecognitionException re) {
8204            reportError(re);
8205            recover(input,re);
8206        }
8207        finally {
8208            if ( state.backtracking>0 ) { memoize(input, 62, trystatement_StartIndex); }
8209        }
8210        dbg.location(893, 6);
8211
8212        }
8213        finally {
8214            dbg.exitRule(getGrammarFileName(), "trystatement");
8215            decRuleLevel();
8216            if ( getRuleLevel()==0 ) {dbg.terminate();}
8217        }
8218
8219        return ;
8220    }
8221    // $ANTLR end "trystatement"
8222
8223
8224    // $ANTLR start "catches"
8225    // src/com/google/doclava/parser/Java.g:895:1: catches : catchClause ( catchClause )* ;
8226    public final void catches() throws RecognitionException {
8227        int catches_StartIndex = input.index();
8228        try { dbg.enterRule(getGrammarFileName(), "catches");
8229        if ( getRuleLevel()==0 ) {dbg.commence();}
8230        incRuleLevel();
8231        dbg.location(895, 1);
8232
8233        try {
8234            if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return ; }
8235            // src/com/google/doclava/parser/Java.g:896:5: ( catchClause ( catchClause )* )
8236            dbg.enterAlt(1);
8237
8238            // src/com/google/doclava/parser/Java.g:896:9: catchClause ( catchClause )*
8239            {
8240            dbg.location(896,9);
8241            pushFollow(FOLLOW_catchClause_in_catches4637);
8242            catchClause();
8243
8244            state._fsp--;
8245            if (state.failed) return ;
8246            dbg.location(897,9);
8247            // src/com/google/doclava/parser/Java.g:897:9: ( catchClause )*
8248            try { dbg.enterSubRule(103);
8249
8250            loop103:
8251            do {
8252                int alt103=2;
8253                try { dbg.enterDecision(103, decisionCanBacktrack[103]);
8254
8255                int LA103_0 = input.LA(1);
8256
8257                if ( (LA103_0==CATCH) ) {
8258                    alt103=1;
8259                }
8260
8261
8262                } finally {dbg.exitDecision(103);}
8263
8264                switch (alt103) {
8265		case 1 :
8266		    dbg.enterAlt(1);
8267
8268		    // src/com/google/doclava/parser/Java.g:897:10: catchClause
8269		    {
8270		    dbg.location(897,10);
8271		    pushFollow(FOLLOW_catchClause_in_catches4648);
8272		    catchClause();
8273
8274		    state._fsp--;
8275		    if (state.failed) return ;
8276
8277		    }
8278		    break;
8279
8280		default :
8281		    break loop103;
8282                }
8283            } while (true);
8284            } finally {dbg.exitSubRule(103);}
8285
8286
8287            }
8288
8289        }
8290        catch (RecognitionException re) {
8291            reportError(re);
8292            recover(input,re);
8293        }
8294        finally {
8295            if ( state.backtracking>0 ) { memoize(input, 63, catches_StartIndex); }
8296        }
8297        dbg.location(899, 5);
8298
8299        }
8300        finally {
8301            dbg.exitRule(getGrammarFileName(), "catches");
8302            decRuleLevel();
8303            if ( getRuleLevel()==0 ) {dbg.terminate();}
8304        }
8305
8306        return ;
8307    }
8308    // $ANTLR end "catches"
8309
8310
8311    // $ANTLR start "catchClause"
8312    // src/com/google/doclava/parser/Java.g:901:1: catchClause : 'catch' '(' formalParameter ')' block ;
8313    public final void catchClause() throws RecognitionException {
8314        int catchClause_StartIndex = input.index();
8315        try { dbg.enterRule(getGrammarFileName(), "catchClause");
8316        if ( getRuleLevel()==0 ) {dbg.commence();}
8317        incRuleLevel();
8318        dbg.location(901, 1);
8319
8320        try {
8321            if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return ; }
8322            // src/com/google/doclava/parser/Java.g:902:5: ( 'catch' '(' formalParameter ')' block )
8323            dbg.enterAlt(1);
8324
8325            // src/com/google/doclava/parser/Java.g:902:9: 'catch' '(' formalParameter ')' block
8326            {
8327            dbg.location(902,9);
8328            match(input,CATCH,FOLLOW_CATCH_in_catchClause4678); if (state.failed) return ;
8329            dbg.location(902,17);
8330            match(input,LPAREN,FOLLOW_LPAREN_in_catchClause4680); if (state.failed) return ;
8331            dbg.location(902,21);
8332            pushFollow(FOLLOW_formalParameter_in_catchClause4682);
8333            formalParameter();
8334
8335            state._fsp--;
8336            if (state.failed) return ;
8337            dbg.location(903,9);
8338            match(input,RPAREN,FOLLOW_RPAREN_in_catchClause4692); if (state.failed) return ;
8339            dbg.location(903,13);
8340            pushFollow(FOLLOW_block_in_catchClause4694);
8341            block();
8342
8343            state._fsp--;
8344            if (state.failed) return ;
8345
8346            }
8347
8348        }
8349        catch (RecognitionException re) {
8350            reportError(re);
8351            recover(input,re);
8352        }
8353        finally {
8354            if ( state.backtracking>0 ) { memoize(input, 64, catchClause_StartIndex); }
8355        }
8356        dbg.location(904, 5);
8357
8358        }
8359        finally {
8360            dbg.exitRule(getGrammarFileName(), "catchClause");
8361            decRuleLevel();
8362            if ( getRuleLevel()==0 ) {dbg.terminate();}
8363        }
8364
8365        return ;
8366    }
8367    // $ANTLR end "catchClause"
8368
8369
8370    // $ANTLR start "formalParameter"
8371    // src/com/google/doclava/parser/Java.g:906:1: formalParameter : variableModifiers type IDENTIFIER ( '[' ']' )* ;
8372    public final void formalParameter() throws RecognitionException {
8373        int formalParameter_StartIndex = input.index();
8374        try { dbg.enterRule(getGrammarFileName(), "formalParameter");
8375        if ( getRuleLevel()==0 ) {dbg.commence();}
8376        incRuleLevel();
8377        dbg.location(906, 1);
8378
8379        try {
8380            if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return ; }
8381            // src/com/google/doclava/parser/Java.g:907:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* )
8382            dbg.enterAlt(1);
8383
8384            // src/com/google/doclava/parser/Java.g:907:9: variableModifiers type IDENTIFIER ( '[' ']' )*
8385            {
8386            dbg.location(907,9);
8387            pushFollow(FOLLOW_variableModifiers_in_formalParameter4713);
8388            variableModifiers();
8389
8390            state._fsp--;
8391            if (state.failed) return ;
8392            dbg.location(907,27);
8393            pushFollow(FOLLOW_type_in_formalParameter4715);
8394            type();
8395
8396            state._fsp--;
8397            if (state.failed) return ;
8398            dbg.location(907,32);
8399            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_formalParameter4717); if (state.failed) return ;
8400            dbg.location(908,9);
8401            // src/com/google/doclava/parser/Java.g:908:9: ( '[' ']' )*
8402            try { dbg.enterSubRule(104);
8403
8404            loop104:
8405            do {
8406                int alt104=2;
8407                try { dbg.enterDecision(104, decisionCanBacktrack[104]);
8408
8409                int LA104_0 = input.LA(1);
8410
8411                if ( (LA104_0==LBRACKET) ) {
8412                    alt104=1;
8413                }
8414
8415
8416                } finally {dbg.exitDecision(104);}
8417
8418                switch (alt104) {
8419		case 1 :
8420		    dbg.enterAlt(1);
8421
8422		    // src/com/google/doclava/parser/Java.g:908:10: '[' ']'
8423		    {
8424		    dbg.location(908,10);
8425		    match(input,LBRACKET,FOLLOW_LBRACKET_in_formalParameter4728); if (state.failed) return ;
8426		    dbg.location(908,14);
8427		    match(input,RBRACKET,FOLLOW_RBRACKET_in_formalParameter4730); if (state.failed) return ;
8428
8429		    }
8430		    break;
8431
8432		default :
8433		    break loop104;
8434                }
8435            } while (true);
8436            } finally {dbg.exitSubRule(104);}
8437
8438
8439            }
8440
8441        }
8442        catch (RecognitionException re) {
8443            reportError(re);
8444            recover(input,re);
8445        }
8446        finally {
8447            if ( state.backtracking>0 ) { memoize(input, 65, formalParameter_StartIndex); }
8448        }
8449        dbg.location(910, 5);
8450
8451        }
8452        finally {
8453            dbg.exitRule(getGrammarFileName(), "formalParameter");
8454            decRuleLevel();
8455            if ( getRuleLevel()==0 ) {dbg.terminate();}
8456        }
8457
8458        return ;
8459    }
8460    // $ANTLR end "formalParameter"
8461
8462
8463    // $ANTLR start "forstatement"
8464    // src/com/google/doclava/parser/Java.g:912:1: forstatement : ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement );
8465    public final void forstatement() throws RecognitionException {
8466        int forstatement_StartIndex = input.index();
8467        try { dbg.enterRule(getGrammarFileName(), "forstatement");
8468        if ( getRuleLevel()==0 ) {dbg.commence();}
8469        incRuleLevel();
8470        dbg.location(912, 1);
8471
8472        try {
8473            if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return ; }
8474            // src/com/google/doclava/parser/Java.g:913:5: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement )
8475            int alt108=2;
8476            try { dbg.enterDecision(108, decisionCanBacktrack[108]);
8477
8478            int LA108_0 = input.LA(1);
8479
8480            if ( (LA108_0==FOR) ) {
8481                int LA108_1 = input.LA(2);
8482
8483                if ( (synpred157_Java()) ) {
8484                    alt108=1;
8485                }
8486                else if ( (true) ) {
8487                    alt108=2;
8488                }
8489                else {
8490                    if (state.backtracking>0) {state.failed=true; return ;}
8491                    NoViableAltException nvae =
8492                        new NoViableAltException("", 108, 1, input);
8493
8494                    dbg.recognitionException(nvae);
8495                    throw nvae;
8496                }
8497            }
8498            else {
8499                if (state.backtracking>0) {state.failed=true; return ;}
8500                NoViableAltException nvae =
8501                    new NoViableAltException("", 108, 0, input);
8502
8503                dbg.recognitionException(nvae);
8504                throw nvae;
8505            }
8506            } finally {dbg.exitDecision(108);}
8507
8508            switch (alt108) {
8509                case 1 :
8510                    dbg.enterAlt(1);
8511
8512                    // src/com/google/doclava/parser/Java.g:915:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement
8513                    {
8514                    dbg.location(915,9);
8515                    match(input,FOR,FOLLOW_FOR_in_forstatement4775); if (state.failed) return ;
8516                    dbg.location(915,15);
8517                    match(input,LPAREN,FOLLOW_LPAREN_in_forstatement4777); if (state.failed) return ;
8518                    dbg.location(915,19);
8519                    pushFollow(FOLLOW_variableModifiers_in_forstatement4779);
8520                    variableModifiers();
8521
8522                    state._fsp--;
8523                    if (state.failed) return ;
8524                    dbg.location(915,37);
8525                    pushFollow(FOLLOW_type_in_forstatement4781);
8526                    type();
8527
8528                    state._fsp--;
8529                    if (state.failed) return ;
8530                    dbg.location(915,42);
8531                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_forstatement4783); if (state.failed) return ;
8532                    dbg.location(915,53);
8533                    match(input,COLON,FOLLOW_COLON_in_forstatement4785); if (state.failed) return ;
8534                    dbg.location(916,9);
8535                    pushFollow(FOLLOW_expression_in_forstatement4795);
8536                    expression();
8537
8538                    state._fsp--;
8539                    if (state.failed) return ;
8540                    dbg.location(916,20);
8541                    match(input,RPAREN,FOLLOW_RPAREN_in_forstatement4797); if (state.failed) return ;
8542                    dbg.location(916,24);
8543                    pushFollow(FOLLOW_statement_in_forstatement4799);
8544                    statement();
8545
8546                    state._fsp--;
8547                    if (state.failed) return ;
8548
8549                    }
8550                    break;
8551                case 2 :
8552                    dbg.enterAlt(2);
8553
8554                    // src/com/google/doclava/parser/Java.g:919:9: 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement
8555                    {
8556                    dbg.location(919,9);
8557                    match(input,FOR,FOLLOW_FOR_in_forstatement4819); if (state.failed) return ;
8558                    dbg.location(919,15);
8559                    match(input,LPAREN,FOLLOW_LPAREN_in_forstatement4821); if (state.failed) return ;
8560                    dbg.location(920,17);
8561                    // src/com/google/doclava/parser/Java.g:920:17: ( forInit )?
8562                    int alt105=2;
8563                    try { dbg.enterSubRule(105);
8564                    try { dbg.enterDecision(105, decisionCanBacktrack[105]);
8565
8566                    int LA105_0 = input.LA(1);
8567
8568                    if ( ((LA105_0>=IDENTIFIER && LA105_0<=NULL)||LA105_0==BOOLEAN||LA105_0==BYTE||LA105_0==CHAR||LA105_0==DOUBLE||LA105_0==FINAL||LA105_0==FLOAT||LA105_0==INT||LA105_0==LONG||LA105_0==NEW||LA105_0==SHORT||LA105_0==SUPER||LA105_0==THIS||LA105_0==VOID||LA105_0==LPAREN||(LA105_0>=BANG && LA105_0<=TILDE)||(LA105_0>=PLUSPLUS && LA105_0<=SUB)||LA105_0==MONKEYS_AT) ) {
8569                        alt105=1;
8570                    }
8571                    } finally {dbg.exitDecision(105);}
8572
8573                    switch (alt105) {
8574                        case 1 :
8575                            dbg.enterAlt(1);
8576
8577                            // src/com/google/doclava/parser/Java.g:920:18: forInit
8578                            {
8579                            dbg.location(920,18);
8580                            pushFollow(FOLLOW_forInit_in_forstatement4840);
8581                            forInit();
8582
8583                            state._fsp--;
8584                            if (state.failed) return ;
8585
8586                            }
8587                            break;
8588
8589                    }
8590                    } finally {dbg.exitSubRule(105);}
8591
8592                    dbg.location(921,20);
8593                    match(input,SEMI,FOLLOW_SEMI_in_forstatement4861); if (state.failed) return ;
8594                    dbg.location(922,17);
8595                    // src/com/google/doclava/parser/Java.g:922:17: ( expression )?
8596                    int alt106=2;
8597                    try { dbg.enterSubRule(106);
8598                    try { dbg.enterDecision(106, decisionCanBacktrack[106]);
8599
8600                    int LA106_0 = input.LA(1);
8601
8602                    if ( ((LA106_0>=IDENTIFIER && LA106_0<=NULL)||LA106_0==BOOLEAN||LA106_0==BYTE||LA106_0==CHAR||LA106_0==DOUBLE||LA106_0==FLOAT||LA106_0==INT||LA106_0==LONG||LA106_0==NEW||LA106_0==SHORT||LA106_0==SUPER||LA106_0==THIS||LA106_0==VOID||LA106_0==LPAREN||(LA106_0>=BANG && LA106_0<=TILDE)||(LA106_0>=PLUSPLUS && LA106_0<=SUB)) ) {
8603                        alt106=1;
8604                    }
8605                    } finally {dbg.exitDecision(106);}
8606
8607                    switch (alt106) {
8608                        case 1 :
8609                            dbg.enterAlt(1);
8610
8611                            // src/com/google/doclava/parser/Java.g:922:18: expression
8612                            {
8613                            dbg.location(922,18);
8614                            pushFollow(FOLLOW_expression_in_forstatement4880);
8615                            expression();
8616
8617                            state._fsp--;
8618                            if (state.failed) return ;
8619
8620                            }
8621                            break;
8622
8623                    }
8624                    } finally {dbg.exitSubRule(106);}
8625
8626                    dbg.location(923,20);
8627                    match(input,SEMI,FOLLOW_SEMI_in_forstatement4901); if (state.failed) return ;
8628                    dbg.location(924,17);
8629                    // src/com/google/doclava/parser/Java.g:924:17: ( expressionList )?
8630                    int alt107=2;
8631                    try { dbg.enterSubRule(107);
8632                    try { dbg.enterDecision(107, decisionCanBacktrack[107]);
8633
8634                    int LA107_0 = input.LA(1);
8635
8636                    if ( ((LA107_0>=IDENTIFIER && LA107_0<=NULL)||LA107_0==BOOLEAN||LA107_0==BYTE||LA107_0==CHAR||LA107_0==DOUBLE||LA107_0==FLOAT||LA107_0==INT||LA107_0==LONG||LA107_0==NEW||LA107_0==SHORT||LA107_0==SUPER||LA107_0==THIS||LA107_0==VOID||LA107_0==LPAREN||(LA107_0>=BANG && LA107_0<=TILDE)||(LA107_0>=PLUSPLUS && LA107_0<=SUB)) ) {
8637                        alt107=1;
8638                    }
8639                    } finally {dbg.exitDecision(107);}
8640
8641                    switch (alt107) {
8642                        case 1 :
8643                            dbg.enterAlt(1);
8644
8645                            // src/com/google/doclava/parser/Java.g:924:18: expressionList
8646                            {
8647                            dbg.location(924,18);
8648                            pushFollow(FOLLOW_expressionList_in_forstatement4920);
8649                            expressionList();
8650
8651                            state._fsp--;
8652                            if (state.failed) return ;
8653
8654                            }
8655                            break;
8656
8657                    }
8658                    } finally {dbg.exitSubRule(107);}
8659
8660                    dbg.location(925,20);
8661                    match(input,RPAREN,FOLLOW_RPAREN_in_forstatement4941); if (state.failed) return ;
8662                    dbg.location(925,24);
8663                    pushFollow(FOLLOW_statement_in_forstatement4943);
8664                    statement();
8665
8666                    state._fsp--;
8667                    if (state.failed) return ;
8668
8669                    }
8670                    break;
8671
8672            }
8673        }
8674        catch (RecognitionException re) {
8675            reportError(re);
8676            recover(input,re);
8677        }
8678        finally {
8679            if ( state.backtracking>0 ) { memoize(input, 66, forstatement_StartIndex); }
8680        }
8681        dbg.location(926, 5);
8682
8683        }
8684        finally {
8685            dbg.exitRule(getGrammarFileName(), "forstatement");
8686            decRuleLevel();
8687            if ( getRuleLevel()==0 ) {dbg.terminate();}
8688        }
8689
8690        return ;
8691    }
8692    // $ANTLR end "forstatement"
8693
8694
8695    // $ANTLR start "forInit"
8696    // src/com/google/doclava/parser/Java.g:928:1: forInit : ( localVariableDeclaration | expressionList );
8697    public final void forInit() throws RecognitionException {
8698        int forInit_StartIndex = input.index();
8699        try { dbg.enterRule(getGrammarFileName(), "forInit");
8700        if ( getRuleLevel()==0 ) {dbg.commence();}
8701        incRuleLevel();
8702        dbg.location(928, 1);
8703
8704        try {
8705            if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return ; }
8706            // src/com/google/doclava/parser/Java.g:929:5: ( localVariableDeclaration | expressionList )
8707            int alt109=2;
8708            try { dbg.enterDecision(109, decisionCanBacktrack[109]);
8709
8710            try {
8711                isCyclicDecision = true;
8712                alt109 = dfa109.predict(input);
8713            }
8714            catch (NoViableAltException nvae) {
8715                dbg.recognitionException(nvae);
8716                throw nvae;
8717            }
8718            } finally {dbg.exitDecision(109);}
8719
8720            switch (alt109) {
8721                case 1 :
8722                    dbg.enterAlt(1);
8723
8724                    // src/com/google/doclava/parser/Java.g:929:9: localVariableDeclaration
8725                    {
8726                    dbg.location(929,9);
8727                    pushFollow(FOLLOW_localVariableDeclaration_in_forInit4962);
8728                    localVariableDeclaration();
8729
8730                    state._fsp--;
8731                    if (state.failed) return ;
8732
8733                    }
8734                    break;
8735                case 2 :
8736                    dbg.enterAlt(2);
8737
8738                    // src/com/google/doclava/parser/Java.g:930:9: expressionList
8739                    {
8740                    dbg.location(930,9);
8741                    pushFollow(FOLLOW_expressionList_in_forInit4972);
8742                    expressionList();
8743
8744                    state._fsp--;
8745                    if (state.failed) return ;
8746
8747                    }
8748                    break;
8749
8750            }
8751        }
8752        catch (RecognitionException re) {
8753            reportError(re);
8754            recover(input,re);
8755        }
8756        finally {
8757            if ( state.backtracking>0 ) { memoize(input, 67, forInit_StartIndex); }
8758        }
8759        dbg.location(931, 5);
8760
8761        }
8762        finally {
8763            dbg.exitRule(getGrammarFileName(), "forInit");
8764            decRuleLevel();
8765            if ( getRuleLevel()==0 ) {dbg.terminate();}
8766        }
8767
8768        return ;
8769    }
8770    // $ANTLR end "forInit"
8771
8772
8773    // $ANTLR start "parExpression"
8774    // src/com/google/doclava/parser/Java.g:933:1: parExpression : '(' expression ')' ;
8775    public final void parExpression() throws RecognitionException {
8776        int parExpression_StartIndex = input.index();
8777        try { dbg.enterRule(getGrammarFileName(), "parExpression");
8778        if ( getRuleLevel()==0 ) {dbg.commence();}
8779        incRuleLevel();
8780        dbg.location(933, 1);
8781
8782        try {
8783            if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return ; }
8784            // src/com/google/doclava/parser/Java.g:934:5: ( '(' expression ')' )
8785            dbg.enterAlt(1);
8786
8787            // src/com/google/doclava/parser/Java.g:934:9: '(' expression ')'
8788            {
8789            dbg.location(934,9);
8790            match(input,LPAREN,FOLLOW_LPAREN_in_parExpression4991); if (state.failed) return ;
8791            dbg.location(934,13);
8792            pushFollow(FOLLOW_expression_in_parExpression4993);
8793            expression();
8794
8795            state._fsp--;
8796            if (state.failed) return ;
8797            dbg.location(934,24);
8798            match(input,RPAREN,FOLLOW_RPAREN_in_parExpression4995); if (state.failed) return ;
8799
8800            }
8801
8802        }
8803        catch (RecognitionException re) {
8804            reportError(re);
8805            recover(input,re);
8806        }
8807        finally {
8808            if ( state.backtracking>0 ) { memoize(input, 68, parExpression_StartIndex); }
8809        }
8810        dbg.location(935, 5);
8811
8812        }
8813        finally {
8814            dbg.exitRule(getGrammarFileName(), "parExpression");
8815            decRuleLevel();
8816            if ( getRuleLevel()==0 ) {dbg.terminate();}
8817        }
8818
8819        return ;
8820    }
8821    // $ANTLR end "parExpression"
8822
8823
8824    // $ANTLR start "expressionList"
8825    // src/com/google/doclava/parser/Java.g:937:1: expressionList : expression ( ',' expression )* ;
8826    public final void expressionList() throws RecognitionException {
8827        int expressionList_StartIndex = input.index();
8828        try { dbg.enterRule(getGrammarFileName(), "expressionList");
8829        if ( getRuleLevel()==0 ) {dbg.commence();}
8830        incRuleLevel();
8831        dbg.location(937, 1);
8832
8833        try {
8834            if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return ; }
8835            // src/com/google/doclava/parser/Java.g:938:5: ( expression ( ',' expression )* )
8836            dbg.enterAlt(1);
8837
8838            // src/com/google/doclava/parser/Java.g:938:9: expression ( ',' expression )*
8839            {
8840            dbg.location(938,9);
8841            pushFollow(FOLLOW_expression_in_expressionList5014);
8842            expression();
8843
8844            state._fsp--;
8845            if (state.failed) return ;
8846            dbg.location(939,9);
8847            // src/com/google/doclava/parser/Java.g:939:9: ( ',' expression )*
8848            try { dbg.enterSubRule(110);
8849
8850            loop110:
8851            do {
8852                int alt110=2;
8853                try { dbg.enterDecision(110, decisionCanBacktrack[110]);
8854
8855                int LA110_0 = input.LA(1);
8856
8857                if ( (LA110_0==COMMA) ) {
8858                    alt110=1;
8859                }
8860
8861
8862                } finally {dbg.exitDecision(110);}
8863
8864                switch (alt110) {
8865		case 1 :
8866		    dbg.enterAlt(1);
8867
8868		    // src/com/google/doclava/parser/Java.g:939:10: ',' expression
8869		    {
8870		    dbg.location(939,10);
8871		    match(input,COMMA,FOLLOW_COMMA_in_expressionList5025); if (state.failed) return ;
8872		    dbg.location(939,14);
8873		    pushFollow(FOLLOW_expression_in_expressionList5027);
8874		    expression();
8875
8876		    state._fsp--;
8877		    if (state.failed) return ;
8878
8879		    }
8880		    break;
8881
8882		default :
8883		    break loop110;
8884                }
8885            } while (true);
8886            } finally {dbg.exitSubRule(110);}
8887
8888
8889            }
8890
8891        }
8892        catch (RecognitionException re) {
8893            reportError(re);
8894            recover(input,re);
8895        }
8896        finally {
8897            if ( state.backtracking>0 ) { memoize(input, 69, expressionList_StartIndex); }
8898        }
8899        dbg.location(941, 5);
8900
8901        }
8902        finally {
8903            dbg.exitRule(getGrammarFileName(), "expressionList");
8904            decRuleLevel();
8905            if ( getRuleLevel()==0 ) {dbg.terminate();}
8906        }
8907
8908        return ;
8909    }
8910    // $ANTLR end "expressionList"
8911
8912
8913    // $ANTLR start "expression"
8914    // src/com/google/doclava/parser/Java.g:944:1: expression : conditionalExpression ( assignmentOperator expression )? ;
8915    public final void expression() throws RecognitionException {
8916        int expression_StartIndex = input.index();
8917        try { dbg.enterRule(getGrammarFileName(), "expression");
8918        if ( getRuleLevel()==0 ) {dbg.commence();}
8919        incRuleLevel();
8920        dbg.location(944, 1);
8921
8922        try {
8923            if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return ; }
8924            // src/com/google/doclava/parser/Java.g:945:5: ( conditionalExpression ( assignmentOperator expression )? )
8925            dbg.enterAlt(1);
8926
8927            // src/com/google/doclava/parser/Java.g:945:9: conditionalExpression ( assignmentOperator expression )?
8928            {
8929            dbg.location(945,9);
8930            pushFollow(FOLLOW_conditionalExpression_in_expression5058);
8931            conditionalExpression();
8932
8933            state._fsp--;
8934            if (state.failed) return ;
8935            dbg.location(946,9);
8936            // src/com/google/doclava/parser/Java.g:946:9: ( assignmentOperator expression )?
8937            int alt111=2;
8938            try { dbg.enterSubRule(111);
8939            try { dbg.enterDecision(111, decisionCanBacktrack[111]);
8940
8941            int LA111_0 = input.LA(1);
8942
8943            if ( (LA111_0==EQ||(LA111_0>=PLUSEQ && LA111_0<=PERCENTEQ)||(LA111_0>=GT && LA111_0<=LT)) ) {
8944                alt111=1;
8945            }
8946            } finally {dbg.exitDecision(111);}
8947
8948            switch (alt111) {
8949                case 1 :
8950                    dbg.enterAlt(1);
8951
8952                    // src/com/google/doclava/parser/Java.g:946:10: assignmentOperator expression
8953                    {
8954                    dbg.location(946,10);
8955                    pushFollow(FOLLOW_assignmentOperator_in_expression5069);
8956                    assignmentOperator();
8957
8958                    state._fsp--;
8959                    if (state.failed) return ;
8960                    dbg.location(946,29);
8961                    pushFollow(FOLLOW_expression_in_expression5071);
8962                    expression();
8963
8964                    state._fsp--;
8965                    if (state.failed) return ;
8966
8967                    }
8968                    break;
8969
8970            }
8971            } finally {dbg.exitSubRule(111);}
8972
8973
8974            }
8975
8976        }
8977        catch (RecognitionException re) {
8978            reportError(re);
8979            recover(input,re);
8980        }
8981        finally {
8982            if ( state.backtracking>0 ) { memoize(input, 70, expression_StartIndex); }
8983        }
8984        dbg.location(948, 5);
8985
8986        }
8987        finally {
8988            dbg.exitRule(getGrammarFileName(), "expression");
8989            decRuleLevel();
8990            if ( getRuleLevel()==0 ) {dbg.terminate();}
8991        }
8992
8993        return ;
8994    }
8995    // $ANTLR end "expression"
8996
8997
8998    // $ANTLR start "assignmentOperator"
8999    // src/com/google/doclava/parser/Java.g:951:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' );
9000    public final void assignmentOperator() throws RecognitionException {
9001        int assignmentOperator_StartIndex = input.index();
9002        try { dbg.enterRule(getGrammarFileName(), "assignmentOperator");
9003        if ( getRuleLevel()==0 ) {dbg.commence();}
9004        incRuleLevel();
9005        dbg.location(951, 1);
9006
9007        try {
9008            if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return ; }
9009            // src/com/google/doclava/parser/Java.g:952:5: ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' )
9010            int alt112=12;
9011            try { dbg.enterDecision(112, decisionCanBacktrack[112]);
9012
9013            try {
9014                isCyclicDecision = true;
9015                alt112 = dfa112.predict(input);
9016            }
9017            catch (NoViableAltException nvae) {
9018                dbg.recognitionException(nvae);
9019                throw nvae;
9020            }
9021            } finally {dbg.exitDecision(112);}
9022
9023            switch (alt112) {
9024                case 1 :
9025                    dbg.enterAlt(1);
9026
9027                    // src/com/google/doclava/parser/Java.g:952:9: '='
9028                    {
9029                    dbg.location(952,9);
9030                    match(input,EQ,FOLLOW_EQ_in_assignmentOperator5102); if (state.failed) return ;
9031
9032                    }
9033                    break;
9034                case 2 :
9035                    dbg.enterAlt(2);
9036
9037                    // src/com/google/doclava/parser/Java.g:953:9: '+='
9038                    {
9039                    dbg.location(953,9);
9040                    match(input,PLUSEQ,FOLLOW_PLUSEQ_in_assignmentOperator5112); if (state.failed) return ;
9041
9042                    }
9043                    break;
9044                case 3 :
9045                    dbg.enterAlt(3);
9046
9047                    // src/com/google/doclava/parser/Java.g:954:9: '-='
9048                    {
9049                    dbg.location(954,9);
9050                    match(input,SUBEQ,FOLLOW_SUBEQ_in_assignmentOperator5122); if (state.failed) return ;
9051
9052                    }
9053                    break;
9054                case 4 :
9055                    dbg.enterAlt(4);
9056
9057                    // src/com/google/doclava/parser/Java.g:955:9: '*='
9058                    {
9059                    dbg.location(955,9);
9060                    match(input,STAREQ,FOLLOW_STAREQ_in_assignmentOperator5132); if (state.failed) return ;
9061
9062                    }
9063                    break;
9064                case 5 :
9065                    dbg.enterAlt(5);
9066
9067                    // src/com/google/doclava/parser/Java.g:956:9: '/='
9068                    {
9069                    dbg.location(956,9);
9070                    match(input,SLASHEQ,FOLLOW_SLASHEQ_in_assignmentOperator5142); if (state.failed) return ;
9071
9072                    }
9073                    break;
9074                case 6 :
9075                    dbg.enterAlt(6);
9076
9077                    // src/com/google/doclava/parser/Java.g:957:9: '&='
9078                    {
9079                    dbg.location(957,9);
9080                    match(input,AMPEQ,FOLLOW_AMPEQ_in_assignmentOperator5152); if (state.failed) return ;
9081
9082                    }
9083                    break;
9084                case 7 :
9085                    dbg.enterAlt(7);
9086
9087                    // src/com/google/doclava/parser/Java.g:958:9: '|='
9088                    {
9089                    dbg.location(958,9);
9090                    match(input,BAREQ,FOLLOW_BAREQ_in_assignmentOperator5162); if (state.failed) return ;
9091
9092                    }
9093                    break;
9094                case 8 :
9095                    dbg.enterAlt(8);
9096
9097                    // src/com/google/doclava/parser/Java.g:959:9: '^='
9098                    {
9099                    dbg.location(959,9);
9100                    match(input,CARETEQ,FOLLOW_CARETEQ_in_assignmentOperator5172); if (state.failed) return ;
9101
9102                    }
9103                    break;
9104                case 9 :
9105                    dbg.enterAlt(9);
9106
9107                    // src/com/google/doclava/parser/Java.g:960:9: '%='
9108                    {
9109                    dbg.location(960,9);
9110                    match(input,PERCENTEQ,FOLLOW_PERCENTEQ_in_assignmentOperator5182); if (state.failed) return ;
9111
9112                    }
9113                    break;
9114                case 10 :
9115                    dbg.enterAlt(10);
9116
9117                    // src/com/google/doclava/parser/Java.g:961:10: '<' '<' '='
9118                    {
9119                    dbg.location(961,10);
9120                    match(input,LT,FOLLOW_LT_in_assignmentOperator5193); if (state.failed) return ;
9121                    dbg.location(961,14);
9122                    match(input,LT,FOLLOW_LT_in_assignmentOperator5195); if (state.failed) return ;
9123                    dbg.location(961,18);
9124                    match(input,EQ,FOLLOW_EQ_in_assignmentOperator5197); if (state.failed) return ;
9125
9126                    }
9127                    break;
9128                case 11 :
9129                    dbg.enterAlt(11);
9130
9131                    // src/com/google/doclava/parser/Java.g:962:10: '>' '>' '>' '='
9132                    {
9133                    dbg.location(962,10);
9134                    match(input,GT,FOLLOW_GT_in_assignmentOperator5208); if (state.failed) return ;
9135                    dbg.location(962,14);
9136                    match(input,GT,FOLLOW_GT_in_assignmentOperator5210); if (state.failed) return ;
9137                    dbg.location(962,18);
9138                    match(input,GT,FOLLOW_GT_in_assignmentOperator5212); if (state.failed) return ;
9139                    dbg.location(962,22);
9140                    match(input,EQ,FOLLOW_EQ_in_assignmentOperator5214); if (state.failed) return ;
9141
9142                    }
9143                    break;
9144                case 12 :
9145                    dbg.enterAlt(12);
9146
9147                    // src/com/google/doclava/parser/Java.g:963:10: '>' '>' '='
9148                    {
9149                    dbg.location(963,10);
9150                    match(input,GT,FOLLOW_GT_in_assignmentOperator5225); if (state.failed) return ;
9151                    dbg.location(963,14);
9152                    match(input,GT,FOLLOW_GT_in_assignmentOperator5227); if (state.failed) return ;
9153                    dbg.location(963,18);
9154                    match(input,EQ,FOLLOW_EQ_in_assignmentOperator5229); if (state.failed) return ;
9155
9156                    }
9157                    break;
9158
9159            }
9160        }
9161        catch (RecognitionException re) {
9162            reportError(re);
9163            recover(input,re);
9164        }
9165        finally {
9166            if ( state.backtracking>0 ) { memoize(input, 71, assignmentOperator_StartIndex); }
9167        }
9168        dbg.location(964, 5);
9169
9170        }
9171        finally {
9172            dbg.exitRule(getGrammarFileName(), "assignmentOperator");
9173            decRuleLevel();
9174            if ( getRuleLevel()==0 ) {dbg.terminate();}
9175        }
9176
9177        return ;
9178    }
9179    // $ANTLR end "assignmentOperator"
9180
9181
9182    // $ANTLR start "conditionalExpression"
9183    // src/com/google/doclava/parser/Java.g:967:1: conditionalExpression : conditionalOrExpression ( '?' expression ':' conditionalExpression )? ;
9184    public final void conditionalExpression() throws RecognitionException {
9185        int conditionalExpression_StartIndex = input.index();
9186        try { dbg.enterRule(getGrammarFileName(), "conditionalExpression");
9187        if ( getRuleLevel()==0 ) {dbg.commence();}
9188        incRuleLevel();
9189        dbg.location(967, 1);
9190
9191        try {
9192            if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return ; }
9193            // src/com/google/doclava/parser/Java.g:968:5: ( conditionalOrExpression ( '?' expression ':' conditionalExpression )? )
9194            dbg.enterAlt(1);
9195
9196            // src/com/google/doclava/parser/Java.g:968:9: conditionalOrExpression ( '?' expression ':' conditionalExpression )?
9197            {
9198            dbg.location(968,9);
9199            pushFollow(FOLLOW_conditionalOrExpression_in_conditionalExpression5249);
9200            conditionalOrExpression();
9201
9202            state._fsp--;
9203            if (state.failed) return ;
9204            dbg.location(969,9);
9205            // src/com/google/doclava/parser/Java.g:969:9: ( '?' expression ':' conditionalExpression )?
9206            int alt113=2;
9207            try { dbg.enterSubRule(113);
9208            try { dbg.enterDecision(113, decisionCanBacktrack[113]);
9209
9210            int LA113_0 = input.LA(1);
9211
9212            if ( (LA113_0==QUES) ) {
9213                alt113=1;
9214            }
9215            } finally {dbg.exitDecision(113);}
9216
9217            switch (alt113) {
9218                case 1 :
9219                    dbg.enterAlt(1);
9220
9221                    // src/com/google/doclava/parser/Java.g:969:10: '?' expression ':' conditionalExpression
9222                    {
9223                    dbg.location(969,10);
9224                    match(input,QUES,FOLLOW_QUES_in_conditionalExpression5260); if (state.failed) return ;
9225                    dbg.location(969,14);
9226                    pushFollow(FOLLOW_expression_in_conditionalExpression5262);
9227                    expression();
9228
9229                    state._fsp--;
9230                    if (state.failed) return ;
9231                    dbg.location(969,25);
9232                    match(input,COLON,FOLLOW_COLON_in_conditionalExpression5264); if (state.failed) return ;
9233                    dbg.location(969,29);
9234                    pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression5266);
9235                    conditionalExpression();
9236
9237                    state._fsp--;
9238                    if (state.failed) return ;
9239
9240                    }
9241                    break;
9242
9243            }
9244            } finally {dbg.exitSubRule(113);}
9245
9246
9247            }
9248
9249        }
9250        catch (RecognitionException re) {
9251            reportError(re);
9252            recover(input,re);
9253        }
9254        finally {
9255            if ( state.backtracking>0 ) { memoize(input, 72, conditionalExpression_StartIndex); }
9256        }
9257        dbg.location(971, 5);
9258
9259        }
9260        finally {
9261            dbg.exitRule(getGrammarFileName(), "conditionalExpression");
9262            decRuleLevel();
9263            if ( getRuleLevel()==0 ) {dbg.terminate();}
9264        }
9265
9266        return ;
9267    }
9268    // $ANTLR end "conditionalExpression"
9269
9270
9271    // $ANTLR start "conditionalOrExpression"
9272    // src/com/google/doclava/parser/Java.g:973:1: conditionalOrExpression : conditionalAndExpression ( '||' conditionalAndExpression )* ;
9273    public final void conditionalOrExpression() throws RecognitionException {
9274        int conditionalOrExpression_StartIndex = input.index();
9275        try { dbg.enterRule(getGrammarFileName(), "conditionalOrExpression");
9276        if ( getRuleLevel()==0 ) {dbg.commence();}
9277        incRuleLevel();
9278        dbg.location(973, 1);
9279
9280        try {
9281            if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return ; }
9282            // src/com/google/doclava/parser/Java.g:974:5: ( conditionalAndExpression ( '||' conditionalAndExpression )* )
9283            dbg.enterAlt(1);
9284
9285            // src/com/google/doclava/parser/Java.g:974:9: conditionalAndExpression ( '||' conditionalAndExpression )*
9286            {
9287            dbg.location(974,9);
9288            pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression5296);
9289            conditionalAndExpression();
9290
9291            state._fsp--;
9292            if (state.failed) return ;
9293            dbg.location(975,9);
9294            // src/com/google/doclava/parser/Java.g:975:9: ( '||' conditionalAndExpression )*
9295            try { dbg.enterSubRule(114);
9296
9297            loop114:
9298            do {
9299                int alt114=2;
9300                try { dbg.enterDecision(114, decisionCanBacktrack[114]);
9301
9302                int LA114_0 = input.LA(1);
9303
9304                if ( (LA114_0==BARBAR) ) {
9305                    alt114=1;
9306                }
9307
9308
9309                } finally {dbg.exitDecision(114);}
9310
9311                switch (alt114) {
9312		case 1 :
9313		    dbg.enterAlt(1);
9314
9315		    // src/com/google/doclava/parser/Java.g:975:10: '||' conditionalAndExpression
9316		    {
9317		    dbg.location(975,10);
9318		    match(input,BARBAR,FOLLOW_BARBAR_in_conditionalOrExpression5307); if (state.failed) return ;
9319		    dbg.location(975,15);
9320		    pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression5309);
9321		    conditionalAndExpression();
9322
9323		    state._fsp--;
9324		    if (state.failed) return ;
9325
9326		    }
9327		    break;
9328
9329		default :
9330		    break loop114;
9331                }
9332            } while (true);
9333            } finally {dbg.exitSubRule(114);}
9334
9335
9336            }
9337
9338        }
9339        catch (RecognitionException re) {
9340            reportError(re);
9341            recover(input,re);
9342        }
9343        finally {
9344            if ( state.backtracking>0 ) { memoize(input, 73, conditionalOrExpression_StartIndex); }
9345        }
9346        dbg.location(977, 5);
9347
9348        }
9349        finally {
9350            dbg.exitRule(getGrammarFileName(), "conditionalOrExpression");
9351            decRuleLevel();
9352            if ( getRuleLevel()==0 ) {dbg.terminate();}
9353        }
9354
9355        return ;
9356    }
9357    // $ANTLR end "conditionalOrExpression"
9358
9359
9360    // $ANTLR start "conditionalAndExpression"
9361    // src/com/google/doclava/parser/Java.g:979:1: conditionalAndExpression : inclusiveOrExpression ( '&&' inclusiveOrExpression )* ;
9362    public final void conditionalAndExpression() throws RecognitionException {
9363        int conditionalAndExpression_StartIndex = input.index();
9364        try { dbg.enterRule(getGrammarFileName(), "conditionalAndExpression");
9365        if ( getRuleLevel()==0 ) {dbg.commence();}
9366        incRuleLevel();
9367        dbg.location(979, 1);
9368
9369        try {
9370            if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return ; }
9371            // src/com/google/doclava/parser/Java.g:980:5: ( inclusiveOrExpression ( '&&' inclusiveOrExpression )* )
9372            dbg.enterAlt(1);
9373
9374            // src/com/google/doclava/parser/Java.g:980:9: inclusiveOrExpression ( '&&' inclusiveOrExpression )*
9375            {
9376            dbg.location(980,9);
9377            pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5339);
9378            inclusiveOrExpression();
9379
9380            state._fsp--;
9381            if (state.failed) return ;
9382            dbg.location(981,9);
9383            // src/com/google/doclava/parser/Java.g:981:9: ( '&&' inclusiveOrExpression )*
9384            try { dbg.enterSubRule(115);
9385
9386            loop115:
9387            do {
9388                int alt115=2;
9389                try { dbg.enterDecision(115, decisionCanBacktrack[115]);
9390
9391                int LA115_0 = input.LA(1);
9392
9393                if ( (LA115_0==AMPAMP) ) {
9394                    alt115=1;
9395                }
9396
9397
9398                } finally {dbg.exitDecision(115);}
9399
9400                switch (alt115) {
9401		case 1 :
9402		    dbg.enterAlt(1);
9403
9404		    // src/com/google/doclava/parser/Java.g:981:10: '&&' inclusiveOrExpression
9405		    {
9406		    dbg.location(981,10);
9407		    match(input,AMPAMP,FOLLOW_AMPAMP_in_conditionalAndExpression5350); if (state.failed) return ;
9408		    dbg.location(981,15);
9409		    pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression5352);
9410		    inclusiveOrExpression();
9411
9412		    state._fsp--;
9413		    if (state.failed) return ;
9414
9415		    }
9416		    break;
9417
9418		default :
9419		    break loop115;
9420                }
9421            } while (true);
9422            } finally {dbg.exitSubRule(115);}
9423
9424
9425            }
9426
9427        }
9428        catch (RecognitionException re) {
9429            reportError(re);
9430            recover(input,re);
9431        }
9432        finally {
9433            if ( state.backtracking>0 ) { memoize(input, 74, conditionalAndExpression_StartIndex); }
9434        }
9435        dbg.location(983, 5);
9436
9437        }
9438        finally {
9439            dbg.exitRule(getGrammarFileName(), "conditionalAndExpression");
9440            decRuleLevel();
9441            if ( getRuleLevel()==0 ) {dbg.terminate();}
9442        }
9443
9444        return ;
9445    }
9446    // $ANTLR end "conditionalAndExpression"
9447
9448
9449    // $ANTLR start "inclusiveOrExpression"
9450    // src/com/google/doclava/parser/Java.g:985:1: inclusiveOrExpression : exclusiveOrExpression ( '|' exclusiveOrExpression )* ;
9451    public final void inclusiveOrExpression() throws RecognitionException {
9452        int inclusiveOrExpression_StartIndex = input.index();
9453        try { dbg.enterRule(getGrammarFileName(), "inclusiveOrExpression");
9454        if ( getRuleLevel()==0 ) {dbg.commence();}
9455        incRuleLevel();
9456        dbg.location(985, 1);
9457
9458        try {
9459            if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return ; }
9460            // src/com/google/doclava/parser/Java.g:986:5: ( exclusiveOrExpression ( '|' exclusiveOrExpression )* )
9461            dbg.enterAlt(1);
9462
9463            // src/com/google/doclava/parser/Java.g:986:9: exclusiveOrExpression ( '|' exclusiveOrExpression )*
9464            {
9465            dbg.location(986,9);
9466            pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5382);
9467            exclusiveOrExpression();
9468
9469            state._fsp--;
9470            if (state.failed) return ;
9471            dbg.location(987,9);
9472            // src/com/google/doclava/parser/Java.g:987:9: ( '|' exclusiveOrExpression )*
9473            try { dbg.enterSubRule(116);
9474
9475            loop116:
9476            do {
9477                int alt116=2;
9478                try { dbg.enterDecision(116, decisionCanBacktrack[116]);
9479
9480                int LA116_0 = input.LA(1);
9481
9482                if ( (LA116_0==BAR) ) {
9483                    alt116=1;
9484                }
9485
9486
9487                } finally {dbg.exitDecision(116);}
9488
9489                switch (alt116) {
9490		case 1 :
9491		    dbg.enterAlt(1);
9492
9493		    // src/com/google/doclava/parser/Java.g:987:10: '|' exclusiveOrExpression
9494		    {
9495		    dbg.location(987,10);
9496		    match(input,BAR,FOLLOW_BAR_in_inclusiveOrExpression5393); if (state.failed) return ;
9497		    dbg.location(987,14);
9498		    pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression5395);
9499		    exclusiveOrExpression();
9500
9501		    state._fsp--;
9502		    if (state.failed) return ;
9503
9504		    }
9505		    break;
9506
9507		default :
9508		    break loop116;
9509                }
9510            } while (true);
9511            } finally {dbg.exitSubRule(116);}
9512
9513
9514            }
9515
9516        }
9517        catch (RecognitionException re) {
9518            reportError(re);
9519            recover(input,re);
9520        }
9521        finally {
9522            if ( state.backtracking>0 ) { memoize(input, 75, inclusiveOrExpression_StartIndex); }
9523        }
9524        dbg.location(989, 5);
9525
9526        }
9527        finally {
9528            dbg.exitRule(getGrammarFileName(), "inclusiveOrExpression");
9529            decRuleLevel();
9530            if ( getRuleLevel()==0 ) {dbg.terminate();}
9531        }
9532
9533        return ;
9534    }
9535    // $ANTLR end "inclusiveOrExpression"
9536
9537
9538    // $ANTLR start "exclusiveOrExpression"
9539    // src/com/google/doclava/parser/Java.g:991:1: exclusiveOrExpression : andExpression ( '^' andExpression )* ;
9540    public final void exclusiveOrExpression() throws RecognitionException {
9541        int exclusiveOrExpression_StartIndex = input.index();
9542        try { dbg.enterRule(getGrammarFileName(), "exclusiveOrExpression");
9543        if ( getRuleLevel()==0 ) {dbg.commence();}
9544        incRuleLevel();
9545        dbg.location(991, 1);
9546
9547        try {
9548            if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return ; }
9549            // src/com/google/doclava/parser/Java.g:992:5: ( andExpression ( '^' andExpression )* )
9550            dbg.enterAlt(1);
9551
9552            // src/com/google/doclava/parser/Java.g:992:9: andExpression ( '^' andExpression )*
9553            {
9554            dbg.location(992,9);
9555            pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression5425);
9556            andExpression();
9557
9558            state._fsp--;
9559            if (state.failed) return ;
9560            dbg.location(993,9);
9561            // src/com/google/doclava/parser/Java.g:993:9: ( '^' andExpression )*
9562            try { dbg.enterSubRule(117);
9563
9564            loop117:
9565            do {
9566                int alt117=2;
9567                try { dbg.enterDecision(117, decisionCanBacktrack[117]);
9568
9569                int LA117_0 = input.LA(1);
9570
9571                if ( (LA117_0==CARET) ) {
9572                    alt117=1;
9573                }
9574
9575
9576                } finally {dbg.exitDecision(117);}
9577
9578                switch (alt117) {
9579		case 1 :
9580		    dbg.enterAlt(1);
9581
9582		    // src/com/google/doclava/parser/Java.g:993:10: '^' andExpression
9583		    {
9584		    dbg.location(993,10);
9585		    match(input,CARET,FOLLOW_CARET_in_exclusiveOrExpression5436); if (state.failed) return ;
9586		    dbg.location(993,14);
9587		    pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression5438);
9588		    andExpression();
9589
9590		    state._fsp--;
9591		    if (state.failed) return ;
9592
9593		    }
9594		    break;
9595
9596		default :
9597		    break loop117;
9598                }
9599            } while (true);
9600            } finally {dbg.exitSubRule(117);}
9601
9602
9603            }
9604
9605        }
9606        catch (RecognitionException re) {
9607            reportError(re);
9608            recover(input,re);
9609        }
9610        finally {
9611            if ( state.backtracking>0 ) { memoize(input, 76, exclusiveOrExpression_StartIndex); }
9612        }
9613        dbg.location(995, 5);
9614
9615        }
9616        finally {
9617            dbg.exitRule(getGrammarFileName(), "exclusiveOrExpression");
9618            decRuleLevel();
9619            if ( getRuleLevel()==0 ) {dbg.terminate();}
9620        }
9621
9622        return ;
9623    }
9624    // $ANTLR end "exclusiveOrExpression"
9625
9626
9627    // $ANTLR start "andExpression"
9628    // src/com/google/doclava/parser/Java.g:997:1: andExpression : equalityExpression ( '&' equalityExpression )* ;
9629    public final void andExpression() throws RecognitionException {
9630        int andExpression_StartIndex = input.index();
9631        try { dbg.enterRule(getGrammarFileName(), "andExpression");
9632        if ( getRuleLevel()==0 ) {dbg.commence();}
9633        incRuleLevel();
9634        dbg.location(997, 1);
9635
9636        try {
9637            if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return ; }
9638            // src/com/google/doclava/parser/Java.g:998:5: ( equalityExpression ( '&' equalityExpression )* )
9639            dbg.enterAlt(1);
9640
9641            // src/com/google/doclava/parser/Java.g:998:9: equalityExpression ( '&' equalityExpression )*
9642            {
9643            dbg.location(998,9);
9644            pushFollow(FOLLOW_equalityExpression_in_andExpression5468);
9645            equalityExpression();
9646
9647            state._fsp--;
9648            if (state.failed) return ;
9649            dbg.location(999,9);
9650            // src/com/google/doclava/parser/Java.g:999:9: ( '&' equalityExpression )*
9651            try { dbg.enterSubRule(118);
9652
9653            loop118:
9654            do {
9655                int alt118=2;
9656                try { dbg.enterDecision(118, decisionCanBacktrack[118]);
9657
9658                int LA118_0 = input.LA(1);
9659
9660                if ( (LA118_0==AMP) ) {
9661                    alt118=1;
9662                }
9663
9664
9665                } finally {dbg.exitDecision(118);}
9666
9667                switch (alt118) {
9668		case 1 :
9669		    dbg.enterAlt(1);
9670
9671		    // src/com/google/doclava/parser/Java.g:999:10: '&' equalityExpression
9672		    {
9673		    dbg.location(999,10);
9674		    match(input,AMP,FOLLOW_AMP_in_andExpression5479); if (state.failed) return ;
9675		    dbg.location(999,14);
9676		    pushFollow(FOLLOW_equalityExpression_in_andExpression5481);
9677		    equalityExpression();
9678
9679		    state._fsp--;
9680		    if (state.failed) return ;
9681
9682		    }
9683		    break;
9684
9685		default :
9686		    break loop118;
9687                }
9688            } while (true);
9689            } finally {dbg.exitSubRule(118);}
9690
9691
9692            }
9693
9694        }
9695        catch (RecognitionException re) {
9696            reportError(re);
9697            recover(input,re);
9698        }
9699        finally {
9700            if ( state.backtracking>0 ) { memoize(input, 77, andExpression_StartIndex); }
9701        }
9702        dbg.location(1001, 5);
9703
9704        }
9705        finally {
9706            dbg.exitRule(getGrammarFileName(), "andExpression");
9707            decRuleLevel();
9708            if ( getRuleLevel()==0 ) {dbg.terminate();}
9709        }
9710
9711        return ;
9712    }
9713    // $ANTLR end "andExpression"
9714
9715
9716    // $ANTLR start "equalityExpression"
9717    // src/com/google/doclava/parser/Java.g:1003:1: equalityExpression : instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* ;
9718    public final void equalityExpression() throws RecognitionException {
9719        int equalityExpression_StartIndex = input.index();
9720        try { dbg.enterRule(getGrammarFileName(), "equalityExpression");
9721        if ( getRuleLevel()==0 ) {dbg.commence();}
9722        incRuleLevel();
9723        dbg.location(1003, 1);
9724
9725        try {
9726            if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return ; }
9727            // src/com/google/doclava/parser/Java.g:1004:5: ( instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* )
9728            dbg.enterAlt(1);
9729
9730            // src/com/google/doclava/parser/Java.g:1004:9: instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )*
9731            {
9732            dbg.location(1004,9);
9733            pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression5511);
9734            instanceOfExpression();
9735
9736            state._fsp--;
9737            if (state.failed) return ;
9738            dbg.location(1005,9);
9739            // src/com/google/doclava/parser/Java.g:1005:9: ( ( '==' | '!=' ) instanceOfExpression )*
9740            try { dbg.enterSubRule(119);
9741
9742            loop119:
9743            do {
9744                int alt119=2;
9745                try { dbg.enterDecision(119, decisionCanBacktrack[119]);
9746
9747                int LA119_0 = input.LA(1);
9748
9749                if ( (LA119_0==EQEQ||LA119_0==BANGEQ) ) {
9750                    alt119=1;
9751                }
9752
9753
9754                } finally {dbg.exitDecision(119);}
9755
9756                switch (alt119) {
9757		case 1 :
9758		    dbg.enterAlt(1);
9759
9760		    // src/com/google/doclava/parser/Java.g:1006:13: ( '==' | '!=' ) instanceOfExpression
9761		    {
9762		    dbg.location(1006,13);
9763		    if ( input.LA(1)==EQEQ||input.LA(1)==BANGEQ ) {
9764		        input.consume();
9765		        state.errorRecovery=false;state.failed=false;
9766		    }
9767		    else {
9768		        if (state.backtracking>0) {state.failed=true; return ;}
9769		        MismatchedSetException mse = new MismatchedSetException(null,input);
9770		        dbg.recognitionException(mse);
9771		        throw mse;
9772		    }
9773
9774		    dbg.location(1009,13);
9775		    pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression5585);
9776		    instanceOfExpression();
9777
9778		    state._fsp--;
9779		    if (state.failed) return ;
9780
9781		    }
9782		    break;
9783
9784		default :
9785		    break loop119;
9786                }
9787            } while (true);
9788            } finally {dbg.exitSubRule(119);}
9789
9790
9791            }
9792
9793        }
9794        catch (RecognitionException re) {
9795            reportError(re);
9796            recover(input,re);
9797        }
9798        finally {
9799            if ( state.backtracking>0 ) { memoize(input, 78, equalityExpression_StartIndex); }
9800        }
9801        dbg.location(1011, 5);
9802
9803        }
9804        finally {
9805            dbg.exitRule(getGrammarFileName(), "equalityExpression");
9806            decRuleLevel();
9807            if ( getRuleLevel()==0 ) {dbg.terminate();}
9808        }
9809
9810        return ;
9811    }
9812    // $ANTLR end "equalityExpression"
9813
9814
9815    // $ANTLR start "instanceOfExpression"
9816    // src/com/google/doclava/parser/Java.g:1013:1: instanceOfExpression : relationalExpression ( 'instanceof' type )? ;
9817    public final void instanceOfExpression() throws RecognitionException {
9818        int instanceOfExpression_StartIndex = input.index();
9819        try { dbg.enterRule(getGrammarFileName(), "instanceOfExpression");
9820        if ( getRuleLevel()==0 ) {dbg.commence();}
9821        incRuleLevel();
9822        dbg.location(1013, 1);
9823
9824        try {
9825            if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return ; }
9826            // src/com/google/doclava/parser/Java.g:1014:5: ( relationalExpression ( 'instanceof' type )? )
9827            dbg.enterAlt(1);
9828
9829            // src/com/google/doclava/parser/Java.g:1014:9: relationalExpression ( 'instanceof' type )?
9830            {
9831            dbg.location(1014,9);
9832            pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression5615);
9833            relationalExpression();
9834
9835            state._fsp--;
9836            if (state.failed) return ;
9837            dbg.location(1015,9);
9838            // src/com/google/doclava/parser/Java.g:1015:9: ( 'instanceof' type )?
9839            int alt120=2;
9840            try { dbg.enterSubRule(120);
9841            try { dbg.enterDecision(120, decisionCanBacktrack[120]);
9842
9843            int LA120_0 = input.LA(1);
9844
9845            if ( (LA120_0==INSTANCEOF) ) {
9846                alt120=1;
9847            }
9848            } finally {dbg.exitDecision(120);}
9849
9850            switch (alt120) {
9851                case 1 :
9852                    dbg.enterAlt(1);
9853
9854                    // src/com/google/doclava/parser/Java.g:1015:10: 'instanceof' type
9855                    {
9856                    dbg.location(1015,10);
9857                    match(input,INSTANCEOF,FOLLOW_INSTANCEOF_in_instanceOfExpression5626); if (state.failed) return ;
9858                    dbg.location(1015,23);
9859                    pushFollow(FOLLOW_type_in_instanceOfExpression5628);
9860                    type();
9861
9862                    state._fsp--;
9863                    if (state.failed) return ;
9864
9865                    }
9866                    break;
9867
9868            }
9869            } finally {dbg.exitSubRule(120);}
9870
9871
9872            }
9873
9874        }
9875        catch (RecognitionException re) {
9876            reportError(re);
9877            recover(input,re);
9878        }
9879        finally {
9880            if ( state.backtracking>0 ) { memoize(input, 79, instanceOfExpression_StartIndex); }
9881        }
9882        dbg.location(1017, 5);
9883
9884        }
9885        finally {
9886            dbg.exitRule(getGrammarFileName(), "instanceOfExpression");
9887            decRuleLevel();
9888            if ( getRuleLevel()==0 ) {dbg.terminate();}
9889        }
9890
9891        return ;
9892    }
9893    // $ANTLR end "instanceOfExpression"
9894
9895
9896    // $ANTLR start "relationalExpression"
9897    // src/com/google/doclava/parser/Java.g:1019:1: relationalExpression : shiftExpression ( relationalOp shiftExpression )* ;
9898    public final void relationalExpression() throws RecognitionException {
9899        int relationalExpression_StartIndex = input.index();
9900        try { dbg.enterRule(getGrammarFileName(), "relationalExpression");
9901        if ( getRuleLevel()==0 ) {dbg.commence();}
9902        incRuleLevel();
9903        dbg.location(1019, 1);
9904
9905        try {
9906            if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return ; }
9907            // src/com/google/doclava/parser/Java.g:1020:5: ( shiftExpression ( relationalOp shiftExpression )* )
9908            dbg.enterAlt(1);
9909
9910            // src/com/google/doclava/parser/Java.g:1020:9: shiftExpression ( relationalOp shiftExpression )*
9911            {
9912            dbg.location(1020,9);
9913            pushFollow(FOLLOW_shiftExpression_in_relationalExpression5658);
9914            shiftExpression();
9915
9916            state._fsp--;
9917            if (state.failed) return ;
9918            dbg.location(1021,9);
9919            // src/com/google/doclava/parser/Java.g:1021:9: ( relationalOp shiftExpression )*
9920            try { dbg.enterSubRule(121);
9921
9922            loop121:
9923            do {
9924                int alt121=2;
9925                try { dbg.enterDecision(121, decisionCanBacktrack[121]);
9926
9927                int LA121_0 = input.LA(1);
9928
9929                if ( (LA121_0==LT) ) {
9930                    int LA121_2 = input.LA(2);
9931
9932                    if ( ((LA121_2>=IDENTIFIER && LA121_2<=NULL)||LA121_2==BOOLEAN||LA121_2==BYTE||LA121_2==CHAR||LA121_2==DOUBLE||LA121_2==FLOAT||LA121_2==INT||LA121_2==LONG||LA121_2==NEW||LA121_2==SHORT||LA121_2==SUPER||LA121_2==THIS||LA121_2==VOID||LA121_2==LPAREN||(LA121_2>=EQ && LA121_2<=TILDE)||(LA121_2>=PLUSPLUS && LA121_2<=SUB)) ) {
9933                        alt121=1;
9934                    }
9935
9936
9937                }
9938                else if ( (LA121_0==GT) ) {
9939                    int LA121_3 = input.LA(2);
9940
9941                    if ( ((LA121_3>=IDENTIFIER && LA121_3<=NULL)||LA121_3==BOOLEAN||LA121_3==BYTE||LA121_3==CHAR||LA121_3==DOUBLE||LA121_3==FLOAT||LA121_3==INT||LA121_3==LONG||LA121_3==NEW||LA121_3==SHORT||LA121_3==SUPER||LA121_3==THIS||LA121_3==VOID||LA121_3==LPAREN||(LA121_3>=EQ && LA121_3<=TILDE)||(LA121_3>=PLUSPLUS && LA121_3<=SUB)) ) {
9942                        alt121=1;
9943                    }
9944
9945
9946                }
9947
9948
9949                } finally {dbg.exitDecision(121);}
9950
9951                switch (alt121) {
9952		case 1 :
9953		    dbg.enterAlt(1);
9954
9955		    // src/com/google/doclava/parser/Java.g:1021:10: relationalOp shiftExpression
9956		    {
9957		    dbg.location(1021,10);
9958		    pushFollow(FOLLOW_relationalOp_in_relationalExpression5669);
9959		    relationalOp();
9960
9961		    state._fsp--;
9962		    if (state.failed) return ;
9963		    dbg.location(1021,23);
9964		    pushFollow(FOLLOW_shiftExpression_in_relationalExpression5671);
9965		    shiftExpression();
9966
9967		    state._fsp--;
9968		    if (state.failed) return ;
9969
9970		    }
9971		    break;
9972
9973		default :
9974		    break loop121;
9975                }
9976            } while (true);
9977            } finally {dbg.exitSubRule(121);}
9978
9979
9980            }
9981
9982        }
9983        catch (RecognitionException re) {
9984            reportError(re);
9985            recover(input,re);
9986        }
9987        finally {
9988            if ( state.backtracking>0 ) { memoize(input, 80, relationalExpression_StartIndex); }
9989        }
9990        dbg.location(1023, 5);
9991
9992        }
9993        finally {
9994            dbg.exitRule(getGrammarFileName(), "relationalExpression");
9995            decRuleLevel();
9996            if ( getRuleLevel()==0 ) {dbg.terminate();}
9997        }
9998
9999        return ;
10000    }
10001    // $ANTLR end "relationalExpression"
10002
10003
10004    // $ANTLR start "relationalOp"
10005    // src/com/google/doclava/parser/Java.g:1025:1: relationalOp : ( '<' '=' | '>' '=' | '<' | '>' );
10006    public final void relationalOp() throws RecognitionException {
10007        int relationalOp_StartIndex = input.index();
10008        try { dbg.enterRule(getGrammarFileName(), "relationalOp");
10009        if ( getRuleLevel()==0 ) {dbg.commence();}
10010        incRuleLevel();
10011        dbg.location(1025, 1);
10012
10013        try {
10014            if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return ; }
10015            // src/com/google/doclava/parser/Java.g:1026:5: ( '<' '=' | '>' '=' | '<' | '>' )
10016            int alt122=4;
10017            try { dbg.enterDecision(122, decisionCanBacktrack[122]);
10018
10019            int LA122_0 = input.LA(1);
10020
10021            if ( (LA122_0==LT) ) {
10022                int LA122_1 = input.LA(2);
10023
10024                if ( (LA122_1==EQ) ) {
10025                    alt122=1;
10026                }
10027                else if ( ((LA122_1>=IDENTIFIER && LA122_1<=NULL)||LA122_1==BOOLEAN||LA122_1==BYTE||LA122_1==CHAR||LA122_1==DOUBLE||LA122_1==FLOAT||LA122_1==INT||LA122_1==LONG||LA122_1==NEW||LA122_1==SHORT||LA122_1==SUPER||LA122_1==THIS||LA122_1==VOID||LA122_1==LPAREN||(LA122_1>=BANG && LA122_1<=TILDE)||(LA122_1>=PLUSPLUS && LA122_1<=SUB)) ) {
10028                    alt122=3;
10029                }
10030                else {
10031                    if (state.backtracking>0) {state.failed=true; return ;}
10032                    NoViableAltException nvae =
10033                        new NoViableAltException("", 122, 1, input);
10034
10035                    dbg.recognitionException(nvae);
10036                    throw nvae;
10037                }
10038            }
10039            else if ( (LA122_0==GT) ) {
10040                int LA122_2 = input.LA(2);
10041
10042                if ( (LA122_2==EQ) ) {
10043                    alt122=2;
10044                }
10045                else if ( ((LA122_2>=IDENTIFIER && LA122_2<=NULL)||LA122_2==BOOLEAN||LA122_2==BYTE||LA122_2==CHAR||LA122_2==DOUBLE||LA122_2==FLOAT||LA122_2==INT||LA122_2==LONG||LA122_2==NEW||LA122_2==SHORT||LA122_2==SUPER||LA122_2==THIS||LA122_2==VOID||LA122_2==LPAREN||(LA122_2>=BANG && LA122_2<=TILDE)||(LA122_2>=PLUSPLUS && LA122_2<=SUB)) ) {
10046                    alt122=4;
10047                }
10048                else {
10049                    if (state.backtracking>0) {state.failed=true; return ;}
10050                    NoViableAltException nvae =
10051                        new NoViableAltException("", 122, 2, input);
10052
10053                    dbg.recognitionException(nvae);
10054                    throw nvae;
10055                }
10056            }
10057            else {
10058                if (state.backtracking>0) {state.failed=true; return ;}
10059                NoViableAltException nvae =
10060                    new NoViableAltException("", 122, 0, input);
10061
10062                dbg.recognitionException(nvae);
10063                throw nvae;
10064            }
10065            } finally {dbg.exitDecision(122);}
10066
10067            switch (alt122) {
10068                case 1 :
10069                    dbg.enterAlt(1);
10070
10071                    // src/com/google/doclava/parser/Java.g:1026:10: '<' '='
10072                    {
10073                    dbg.location(1026,10);
10074                    match(input,LT,FOLLOW_LT_in_relationalOp5702); if (state.failed) return ;
10075                    dbg.location(1026,14);
10076                    match(input,EQ,FOLLOW_EQ_in_relationalOp5704); if (state.failed) return ;
10077
10078                    }
10079                    break;
10080                case 2 :
10081                    dbg.enterAlt(2);
10082
10083                    // src/com/google/doclava/parser/Java.g:1027:10: '>' '='
10084                    {
10085                    dbg.location(1027,10);
10086                    match(input,GT,FOLLOW_GT_in_relationalOp5715); if (state.failed) return ;
10087                    dbg.location(1027,14);
10088                    match(input,EQ,FOLLOW_EQ_in_relationalOp5717); if (state.failed) return ;
10089
10090                    }
10091                    break;
10092                case 3 :
10093                    dbg.enterAlt(3);
10094
10095                    // src/com/google/doclava/parser/Java.g:1028:9: '<'
10096                    {
10097                    dbg.location(1028,9);
10098                    match(input,LT,FOLLOW_LT_in_relationalOp5727); if (state.failed) return ;
10099
10100                    }
10101                    break;
10102                case 4 :
10103                    dbg.enterAlt(4);
10104
10105                    // src/com/google/doclava/parser/Java.g:1029:9: '>'
10106                    {
10107                    dbg.location(1029,9);
10108                    match(input,GT,FOLLOW_GT_in_relationalOp5737); if (state.failed) return ;
10109
10110                    }
10111                    break;
10112
10113            }
10114        }
10115        catch (RecognitionException re) {
10116            reportError(re);
10117            recover(input,re);
10118        }
10119        finally {
10120            if ( state.backtracking>0 ) { memoize(input, 81, relationalOp_StartIndex); }
10121        }
10122        dbg.location(1030, 5);
10123
10124        }
10125        finally {
10126            dbg.exitRule(getGrammarFileName(), "relationalOp");
10127            decRuleLevel();
10128            if ( getRuleLevel()==0 ) {dbg.terminate();}
10129        }
10130
10131        return ;
10132    }
10133    // $ANTLR end "relationalOp"
10134
10135
10136    // $ANTLR start "shiftExpression"
10137    // src/com/google/doclava/parser/Java.g:1032:1: shiftExpression : additiveExpression ( shiftOp additiveExpression )* ;
10138    public final void shiftExpression() throws RecognitionException {
10139        int shiftExpression_StartIndex = input.index();
10140        try { dbg.enterRule(getGrammarFileName(), "shiftExpression");
10141        if ( getRuleLevel()==0 ) {dbg.commence();}
10142        incRuleLevel();
10143        dbg.location(1032, 1);
10144
10145        try {
10146            if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return ; }
10147            // src/com/google/doclava/parser/Java.g:1033:5: ( additiveExpression ( shiftOp additiveExpression )* )
10148            dbg.enterAlt(1);
10149
10150            // src/com/google/doclava/parser/Java.g:1033:9: additiveExpression ( shiftOp additiveExpression )*
10151            {
10152            dbg.location(1033,9);
10153            pushFollow(FOLLOW_additiveExpression_in_shiftExpression5756);
10154            additiveExpression();
10155
10156            state._fsp--;
10157            if (state.failed) return ;
10158            dbg.location(1034,9);
10159            // src/com/google/doclava/parser/Java.g:1034:9: ( shiftOp additiveExpression )*
10160            try { dbg.enterSubRule(123);
10161
10162            loop123:
10163            do {
10164                int alt123=2;
10165                try { dbg.enterDecision(123, decisionCanBacktrack[123]);
10166
10167                int LA123_0 = input.LA(1);
10168
10169                if ( (LA123_0==LT) ) {
10170                    int LA123_1 = input.LA(2);
10171
10172                    if ( (LA123_1==LT) ) {
10173                        int LA123_4 = input.LA(3);
10174
10175                        if ( ((LA123_4>=IDENTIFIER && LA123_4<=NULL)||LA123_4==BOOLEAN||LA123_4==BYTE||LA123_4==CHAR||LA123_4==DOUBLE||LA123_4==FLOAT||LA123_4==INT||LA123_4==LONG||LA123_4==NEW||LA123_4==SHORT||LA123_4==SUPER||LA123_4==THIS||LA123_4==VOID||LA123_4==LPAREN||(LA123_4>=BANG && LA123_4<=TILDE)||(LA123_4>=PLUSPLUS && LA123_4<=SUB)) ) {
10176                            alt123=1;
10177                        }
10178
10179
10180                    }
10181
10182
10183                }
10184                else if ( (LA123_0==GT) ) {
10185                    int LA123_2 = input.LA(2);
10186
10187                    if ( (LA123_2==GT) ) {
10188                        int LA123_5 = input.LA(3);
10189
10190                        if ( (LA123_5==GT) ) {
10191                            int LA123_7 = input.LA(4);
10192
10193                            if ( ((LA123_7>=IDENTIFIER && LA123_7<=NULL)||LA123_7==BOOLEAN||LA123_7==BYTE||LA123_7==CHAR||LA123_7==DOUBLE||LA123_7==FLOAT||LA123_7==INT||LA123_7==LONG||LA123_7==NEW||LA123_7==SHORT||LA123_7==SUPER||LA123_7==THIS||LA123_7==VOID||LA123_7==LPAREN||(LA123_7>=BANG && LA123_7<=TILDE)||(LA123_7>=PLUSPLUS && LA123_7<=SUB)) ) {
10194                                alt123=1;
10195                            }
10196
10197
10198                        }
10199                        else if ( ((LA123_5>=IDENTIFIER && LA123_5<=NULL)||LA123_5==BOOLEAN||LA123_5==BYTE||LA123_5==CHAR||LA123_5==DOUBLE||LA123_5==FLOAT||LA123_5==INT||LA123_5==LONG||LA123_5==NEW||LA123_5==SHORT||LA123_5==SUPER||LA123_5==THIS||LA123_5==VOID||LA123_5==LPAREN||(LA123_5>=BANG && LA123_5<=TILDE)||(LA123_5>=PLUSPLUS && LA123_5<=SUB)) ) {
10200                            alt123=1;
10201                        }
10202
10203
10204                    }
10205
10206
10207                }
10208
10209
10210                } finally {dbg.exitDecision(123);}
10211
10212                switch (alt123) {
10213		case 1 :
10214		    dbg.enterAlt(1);
10215
10216		    // src/com/google/doclava/parser/Java.g:1034:10: shiftOp additiveExpression
10217		    {
10218		    dbg.location(1034,10);
10219		    pushFollow(FOLLOW_shiftOp_in_shiftExpression5767);
10220		    shiftOp();
10221
10222		    state._fsp--;
10223		    if (state.failed) return ;
10224		    dbg.location(1034,18);
10225		    pushFollow(FOLLOW_additiveExpression_in_shiftExpression5769);
10226		    additiveExpression();
10227
10228		    state._fsp--;
10229		    if (state.failed) return ;
10230
10231		    }
10232		    break;
10233
10234		default :
10235		    break loop123;
10236                }
10237            } while (true);
10238            } finally {dbg.exitSubRule(123);}
10239
10240
10241            }
10242
10243        }
10244        catch (RecognitionException re) {
10245            reportError(re);
10246            recover(input,re);
10247        }
10248        finally {
10249            if ( state.backtracking>0 ) { memoize(input, 82, shiftExpression_StartIndex); }
10250        }
10251        dbg.location(1036, 5);
10252
10253        }
10254        finally {
10255            dbg.exitRule(getGrammarFileName(), "shiftExpression");
10256            decRuleLevel();
10257            if ( getRuleLevel()==0 ) {dbg.terminate();}
10258        }
10259
10260        return ;
10261    }
10262    // $ANTLR end "shiftExpression"
10263
10264
10265    // $ANTLR start "shiftOp"
10266    // src/com/google/doclava/parser/Java.g:1039:1: shiftOp : ( '<' '<' | '>' '>' '>' | '>' '>' );
10267    public final void shiftOp() throws RecognitionException {
10268        int shiftOp_StartIndex = input.index();
10269        try { dbg.enterRule(getGrammarFileName(), "shiftOp");
10270        if ( getRuleLevel()==0 ) {dbg.commence();}
10271        incRuleLevel();
10272        dbg.location(1039, 1);
10273
10274        try {
10275            if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return ; }
10276            // src/com/google/doclava/parser/Java.g:1040:5: ( '<' '<' | '>' '>' '>' | '>' '>' )
10277            int alt124=3;
10278            try { dbg.enterDecision(124, decisionCanBacktrack[124]);
10279
10280            int LA124_0 = input.LA(1);
10281
10282            if ( (LA124_0==LT) ) {
10283                alt124=1;
10284            }
10285            else if ( (LA124_0==GT) ) {
10286                int LA124_2 = input.LA(2);
10287
10288                if ( (LA124_2==GT) ) {
10289                    int LA124_3 = input.LA(3);
10290
10291                    if ( (LA124_3==GT) ) {
10292                        alt124=2;
10293                    }
10294                    else if ( ((LA124_3>=IDENTIFIER && LA124_3<=NULL)||LA124_3==BOOLEAN||LA124_3==BYTE||LA124_3==CHAR||LA124_3==DOUBLE||LA124_3==FLOAT||LA124_3==INT||LA124_3==LONG||LA124_3==NEW||LA124_3==SHORT||LA124_3==SUPER||LA124_3==THIS||LA124_3==VOID||LA124_3==LPAREN||(LA124_3>=BANG && LA124_3<=TILDE)||(LA124_3>=PLUSPLUS && LA124_3<=SUB)) ) {
10295                        alt124=3;
10296                    }
10297                    else {
10298                        if (state.backtracking>0) {state.failed=true; return ;}
10299                        NoViableAltException nvae =
10300                            new NoViableAltException("", 124, 3, input);
10301
10302                        dbg.recognitionException(nvae);
10303                        throw nvae;
10304                    }
10305                }
10306                else {
10307                    if (state.backtracking>0) {state.failed=true; return ;}
10308                    NoViableAltException nvae =
10309                        new NoViableAltException("", 124, 2, input);
10310
10311                    dbg.recognitionException(nvae);
10312                    throw nvae;
10313                }
10314            }
10315            else {
10316                if (state.backtracking>0) {state.failed=true; return ;}
10317                NoViableAltException nvae =
10318                    new NoViableAltException("", 124, 0, input);
10319
10320                dbg.recognitionException(nvae);
10321                throw nvae;
10322            }
10323            } finally {dbg.exitDecision(124);}
10324
10325            switch (alt124) {
10326                case 1 :
10327                    dbg.enterAlt(1);
10328
10329                    // src/com/google/doclava/parser/Java.g:1040:10: '<' '<'
10330                    {
10331                    dbg.location(1040,10);
10332                    match(input,LT,FOLLOW_LT_in_shiftOp5801); if (state.failed) return ;
10333                    dbg.location(1040,14);
10334                    match(input,LT,FOLLOW_LT_in_shiftOp5803); if (state.failed) return ;
10335
10336                    }
10337                    break;
10338                case 2 :
10339                    dbg.enterAlt(2);
10340
10341                    // src/com/google/doclava/parser/Java.g:1041:10: '>' '>' '>'
10342                    {
10343                    dbg.location(1041,10);
10344                    match(input,GT,FOLLOW_GT_in_shiftOp5814); if (state.failed) return ;
10345                    dbg.location(1041,14);
10346                    match(input,GT,FOLLOW_GT_in_shiftOp5816); if (state.failed) return ;
10347                    dbg.location(1041,18);
10348                    match(input,GT,FOLLOW_GT_in_shiftOp5818); if (state.failed) return ;
10349
10350                    }
10351                    break;
10352                case 3 :
10353                    dbg.enterAlt(3);
10354
10355                    // src/com/google/doclava/parser/Java.g:1042:10: '>' '>'
10356                    {
10357                    dbg.location(1042,10);
10358                    match(input,GT,FOLLOW_GT_in_shiftOp5829); if (state.failed) return ;
10359                    dbg.location(1042,14);
10360                    match(input,GT,FOLLOW_GT_in_shiftOp5831); if (state.failed) return ;
10361
10362                    }
10363                    break;
10364
10365            }
10366        }
10367        catch (RecognitionException re) {
10368            reportError(re);
10369            recover(input,re);
10370        }
10371        finally {
10372            if ( state.backtracking>0 ) { memoize(input, 83, shiftOp_StartIndex); }
10373        }
10374        dbg.location(1043, 5);
10375
10376        }
10377        finally {
10378            dbg.exitRule(getGrammarFileName(), "shiftOp");
10379            decRuleLevel();
10380            if ( getRuleLevel()==0 ) {dbg.terminate();}
10381        }
10382
10383        return ;
10384    }
10385    // $ANTLR end "shiftOp"
10386
10387
10388    // $ANTLR start "additiveExpression"
10389    // src/com/google/doclava/parser/Java.g:1046:1: additiveExpression : multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* ;
10390    public final void additiveExpression() throws RecognitionException {
10391        int additiveExpression_StartIndex = input.index();
10392        try { dbg.enterRule(getGrammarFileName(), "additiveExpression");
10393        if ( getRuleLevel()==0 ) {dbg.commence();}
10394        incRuleLevel();
10395        dbg.location(1046, 1);
10396
10397        try {
10398            if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return ; }
10399            // src/com/google/doclava/parser/Java.g:1047:5: ( multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* )
10400            dbg.enterAlt(1);
10401
10402            // src/com/google/doclava/parser/Java.g:1047:9: multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )*
10403            {
10404            dbg.location(1047,9);
10405            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression5851);
10406            multiplicativeExpression();
10407
10408            state._fsp--;
10409            if (state.failed) return ;
10410            dbg.location(1048,9);
10411            // src/com/google/doclava/parser/Java.g:1048:9: ( ( '+' | '-' ) multiplicativeExpression )*
10412            try { dbg.enterSubRule(125);
10413
10414            loop125:
10415            do {
10416                int alt125=2;
10417                try { dbg.enterDecision(125, decisionCanBacktrack[125]);
10418
10419                int LA125_0 = input.LA(1);
10420
10421                if ( ((LA125_0>=PLUS && LA125_0<=SUB)) ) {
10422                    alt125=1;
10423                }
10424
10425
10426                } finally {dbg.exitDecision(125);}
10427
10428                switch (alt125) {
10429		case 1 :
10430		    dbg.enterAlt(1);
10431
10432		    // src/com/google/doclava/parser/Java.g:1049:13: ( '+' | '-' ) multiplicativeExpression
10433		    {
10434		    dbg.location(1049,13);
10435		    if ( (input.LA(1)>=PLUS && input.LA(1)<=SUB) ) {
10436		        input.consume();
10437		        state.errorRecovery=false;state.failed=false;
10438		    }
10439		    else {
10440		        if (state.backtracking>0) {state.failed=true; return ;}
10441		        MismatchedSetException mse = new MismatchedSetException(null,input);
10442		        dbg.recognitionException(mse);
10443		        throw mse;
10444		    }
10445
10446		    dbg.location(1052,13);
10447		    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression5925);
10448		    multiplicativeExpression();
10449
10450		    state._fsp--;
10451		    if (state.failed) return ;
10452
10453		    }
10454		    break;
10455
10456		default :
10457		    break loop125;
10458                }
10459            } while (true);
10460            } finally {dbg.exitSubRule(125);}
10461
10462
10463            }
10464
10465        }
10466        catch (RecognitionException re) {
10467            reportError(re);
10468            recover(input,re);
10469        }
10470        finally {
10471            if ( state.backtracking>0 ) { memoize(input, 84, additiveExpression_StartIndex); }
10472        }
10473        dbg.location(1054, 5);
10474
10475        }
10476        finally {
10477            dbg.exitRule(getGrammarFileName(), "additiveExpression");
10478            decRuleLevel();
10479            if ( getRuleLevel()==0 ) {dbg.terminate();}
10480        }
10481
10482        return ;
10483    }
10484    // $ANTLR end "additiveExpression"
10485
10486
10487    // $ANTLR start "multiplicativeExpression"
10488    // src/com/google/doclava/parser/Java.g:1056:1: multiplicativeExpression : unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* ;
10489    public final void multiplicativeExpression() throws RecognitionException {
10490        int multiplicativeExpression_StartIndex = input.index();
10491        try { dbg.enterRule(getGrammarFileName(), "multiplicativeExpression");
10492        if ( getRuleLevel()==0 ) {dbg.commence();}
10493        incRuleLevel();
10494        dbg.location(1056, 1);
10495
10496        try {
10497            if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return ; }
10498            // src/com/google/doclava/parser/Java.g:1057:5: ( unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* )
10499            dbg.enterAlt(1);
10500
10501            // src/com/google/doclava/parser/Java.g:1058:9: unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )*
10502            {
10503            dbg.location(1058,9);
10504            pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression5962);
10505            unaryExpression();
10506
10507            state._fsp--;
10508            if (state.failed) return ;
10509            dbg.location(1059,9);
10510            // src/com/google/doclava/parser/Java.g:1059:9: ( ( '*' | '/' | '%' ) unaryExpression )*
10511            try { dbg.enterSubRule(126);
10512
10513            loop126:
10514            do {
10515                int alt126=2;
10516                try { dbg.enterDecision(126, decisionCanBacktrack[126]);
10517
10518                int LA126_0 = input.LA(1);
10519
10520                if ( ((LA126_0>=STAR && LA126_0<=SLASH)||LA126_0==PERCENT) ) {
10521                    alt126=1;
10522                }
10523
10524
10525                } finally {dbg.exitDecision(126);}
10526
10527                switch (alt126) {
10528		case 1 :
10529		    dbg.enterAlt(1);
10530
10531		    // src/com/google/doclava/parser/Java.g:1060:13: ( '*' | '/' | '%' ) unaryExpression
10532		    {
10533		    dbg.location(1060,13);
10534		    if ( (input.LA(1)>=STAR && input.LA(1)<=SLASH)||input.LA(1)==PERCENT ) {
10535		        input.consume();
10536		        state.errorRecovery=false;state.failed=false;
10537		    }
10538		    else {
10539		        if (state.backtracking>0) {state.failed=true; return ;}
10540		        MismatchedSetException mse = new MismatchedSetException(null,input);
10541		        dbg.recognitionException(mse);
10542		        throw mse;
10543		    }
10544
10545		    dbg.location(1064,13);
10546		    pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression6054);
10547		    unaryExpression();
10548
10549		    state._fsp--;
10550		    if (state.failed) return ;
10551
10552		    }
10553		    break;
10554
10555		default :
10556		    break loop126;
10557                }
10558            } while (true);
10559            } finally {dbg.exitSubRule(126);}
10560
10561
10562            }
10563
10564        }
10565        catch (RecognitionException re) {
10566            reportError(re);
10567            recover(input,re);
10568        }
10569        finally {
10570            if ( state.backtracking>0 ) { memoize(input, 85, multiplicativeExpression_StartIndex); }
10571        }
10572        dbg.location(1066, 5);
10573
10574        }
10575        finally {
10576            dbg.exitRule(getGrammarFileName(), "multiplicativeExpression");
10577            decRuleLevel();
10578            if ( getRuleLevel()==0 ) {dbg.terminate();}
10579        }
10580
10581        return ;
10582    }
10583    // $ANTLR end "multiplicativeExpression"
10584
10585
10586    // $ANTLR start "unaryExpression"
10587    // src/com/google/doclava/parser/Java.g:1068:1: unaryExpression : ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus );
10588    public final void unaryExpression() throws RecognitionException {
10589        int unaryExpression_StartIndex = input.index();
10590        try { dbg.enterRule(getGrammarFileName(), "unaryExpression");
10591        if ( getRuleLevel()==0 ) {dbg.commence();}
10592        incRuleLevel();
10593        dbg.location(1068, 1);
10594
10595        try {
10596            if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return ; }
10597            // src/com/google/doclava/parser/Java.g:1073:5: ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus )
10598            int alt127=5;
10599            try { dbg.enterDecision(127, decisionCanBacktrack[127]);
10600
10601            switch ( input.LA(1) ) {
10602            case PLUS:
10603                {
10604                alt127=1;
10605                }
10606                break;
10607            case SUB:
10608                {
10609                alt127=2;
10610                }
10611                break;
10612            case PLUSPLUS:
10613                {
10614                alt127=3;
10615                }
10616                break;
10617            case SUBSUB:
10618                {
10619                alt127=4;
10620                }
10621                break;
10622            case IDENTIFIER:
10623            case INTLITERAL:
10624            case LONGLITERAL:
10625            case FLOATLITERAL:
10626            case DOUBLELITERAL:
10627            case CHARLITERAL:
10628            case STRINGLITERAL:
10629            case TRUE:
10630            case FALSE:
10631            case NULL:
10632            case BOOLEAN:
10633            case BYTE:
10634            case CHAR:
10635            case DOUBLE:
10636            case FLOAT:
10637            case INT:
10638            case LONG:
10639            case NEW:
10640            case SHORT:
10641            case SUPER:
10642            case THIS:
10643            case VOID:
10644            case LPAREN:
10645            case BANG:
10646            case TILDE:
10647                {
10648                alt127=5;
10649                }
10650                break;
10651            default:
10652                if (state.backtracking>0) {state.failed=true; return ;}
10653                NoViableAltException nvae =
10654                    new NoViableAltException("", 127, 0, input);
10655
10656                dbg.recognitionException(nvae);
10657                throw nvae;
10658            }
10659
10660            } finally {dbg.exitDecision(127);}
10661
10662            switch (alt127) {
10663                case 1 :
10664                    dbg.enterAlt(1);
10665
10666                    // src/com/google/doclava/parser/Java.g:1073:9: '+' unaryExpression
10667                    {
10668                    dbg.location(1073,9);
10669                    match(input,PLUS,FOLLOW_PLUS_in_unaryExpression6086); if (state.failed) return ;
10670                    dbg.location(1073,14);
10671                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression6089);
10672                    unaryExpression();
10673
10674                    state._fsp--;
10675                    if (state.failed) return ;
10676
10677                    }
10678                    break;
10679                case 2 :
10680                    dbg.enterAlt(2);
10681
10682                    // src/com/google/doclava/parser/Java.g:1074:9: '-' unaryExpression
10683                    {
10684                    dbg.location(1074,9);
10685                    match(input,SUB,FOLLOW_SUB_in_unaryExpression6099); if (state.failed) return ;
10686                    dbg.location(1074,13);
10687                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression6101);
10688                    unaryExpression();
10689
10690                    state._fsp--;
10691                    if (state.failed) return ;
10692
10693                    }
10694                    break;
10695                case 3 :
10696                    dbg.enterAlt(3);
10697
10698                    // src/com/google/doclava/parser/Java.g:1075:9: '++' unaryExpression
10699                    {
10700                    dbg.location(1075,9);
10701                    match(input,PLUSPLUS,FOLLOW_PLUSPLUS_in_unaryExpression6111); if (state.failed) return ;
10702                    dbg.location(1075,14);
10703                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression6113);
10704                    unaryExpression();
10705
10706                    state._fsp--;
10707                    if (state.failed) return ;
10708
10709                    }
10710                    break;
10711                case 4 :
10712                    dbg.enterAlt(4);
10713
10714                    // src/com/google/doclava/parser/Java.g:1076:9: '--' unaryExpression
10715                    {
10716                    dbg.location(1076,9);
10717                    match(input,SUBSUB,FOLLOW_SUBSUB_in_unaryExpression6123); if (state.failed) return ;
10718                    dbg.location(1076,14);
10719                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression6125);
10720                    unaryExpression();
10721
10722                    state._fsp--;
10723                    if (state.failed) return ;
10724
10725                    }
10726                    break;
10727                case 5 :
10728                    dbg.enterAlt(5);
10729
10730                    // src/com/google/doclava/parser/Java.g:1077:9: unaryExpressionNotPlusMinus
10731                    {
10732                    dbg.location(1077,9);
10733                    pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression6135);
10734                    unaryExpressionNotPlusMinus();
10735
10736                    state._fsp--;
10737                    if (state.failed) return ;
10738
10739                    }
10740                    break;
10741
10742            }
10743        }
10744        catch (RecognitionException re) {
10745            reportError(re);
10746            recover(input,re);
10747        }
10748        finally {
10749            if ( state.backtracking>0 ) { memoize(input, 86, unaryExpression_StartIndex); }
10750        }
10751        dbg.location(1078, 5);
10752
10753        }
10754        finally {
10755            dbg.exitRule(getGrammarFileName(), "unaryExpression");
10756            decRuleLevel();
10757            if ( getRuleLevel()==0 ) {dbg.terminate();}
10758        }
10759
10760        return ;
10761    }
10762    // $ANTLR end "unaryExpression"
10763
10764
10765    // $ANTLR start "unaryExpressionNotPlusMinus"
10766    // src/com/google/doclava/parser/Java.g:1080:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? );
10767    public final void unaryExpressionNotPlusMinus() throws RecognitionException {
10768        int unaryExpressionNotPlusMinus_StartIndex = input.index();
10769        try { dbg.enterRule(getGrammarFileName(), "unaryExpressionNotPlusMinus");
10770        if ( getRuleLevel()==0 ) {dbg.commence();}
10771        incRuleLevel();
10772        dbg.location(1080, 1);
10773
10774        try {
10775            if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return ; }
10776            // src/com/google/doclava/parser/Java.g:1081:5: ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? )
10777            int alt130=4;
10778            try { dbg.enterDecision(130, decisionCanBacktrack[130]);
10779
10780            try {
10781                isCyclicDecision = true;
10782                alt130 = dfa130.predict(input);
10783            }
10784            catch (NoViableAltException nvae) {
10785                dbg.recognitionException(nvae);
10786                throw nvae;
10787            }
10788            } finally {dbg.exitDecision(130);}
10789
10790            switch (alt130) {
10791                case 1 :
10792                    dbg.enterAlt(1);
10793
10794                    // src/com/google/doclava/parser/Java.g:1081:9: '~' unaryExpression
10795                    {
10796                    dbg.location(1081,9);
10797                    match(input,TILDE,FOLLOW_TILDE_in_unaryExpressionNotPlusMinus6154); if (state.failed) return ;
10798                    dbg.location(1081,13);
10799                    pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6156);
10800                    unaryExpression();
10801
10802                    state._fsp--;
10803                    if (state.failed) return ;
10804
10805                    }
10806                    break;
10807                case 2 :
10808                    dbg.enterAlt(2);
10809
10810                    // src/com/google/doclava/parser/Java.g:1082:9: '!' unaryExpression
10811                    {
10812                    dbg.location(1082,9);
10813                    match(input,BANG,FOLLOW_BANG_in_unaryExpressionNotPlusMinus6166); if (state.failed) return ;
10814                    dbg.location(1082,13);
10815                    pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus6168);
10816                    unaryExpression();
10817
10818                    state._fsp--;
10819                    if (state.failed) return ;
10820
10821                    }
10822                    break;
10823                case 3 :
10824                    dbg.enterAlt(3);
10825
10826                    // src/com/google/doclava/parser/Java.g:1083:9: castExpression
10827                    {
10828                    dbg.location(1083,9);
10829                    pushFollow(FOLLOW_castExpression_in_unaryExpressionNotPlusMinus6178);
10830                    castExpression();
10831
10832                    state._fsp--;
10833                    if (state.failed) return ;
10834
10835                    }
10836                    break;
10837                case 4 :
10838                    dbg.enterAlt(4);
10839
10840                    // src/com/google/doclava/parser/Java.g:1084:9: primary ( selector )* ( '++' | '--' )?
10841                    {
10842                    dbg.location(1084,9);
10843                    pushFollow(FOLLOW_primary_in_unaryExpressionNotPlusMinus6188);
10844                    primary();
10845
10846                    state._fsp--;
10847                    if (state.failed) return ;
10848                    dbg.location(1085,9);
10849                    // src/com/google/doclava/parser/Java.g:1085:9: ( selector )*
10850                    try { dbg.enterSubRule(128);
10851
10852                    loop128:
10853                    do {
10854                        int alt128=2;
10855                        try { dbg.enterDecision(128, decisionCanBacktrack[128]);
10856
10857                        int LA128_0 = input.LA(1);
10858
10859                        if ( (LA128_0==LBRACKET||LA128_0==DOT) ) {
10860                            alt128=1;
10861                        }
10862
10863
10864                        } finally {dbg.exitDecision(128);}
10865
10866                        switch (alt128) {
10867			case 1 :
10868			    dbg.enterAlt(1);
10869
10870			    // src/com/google/doclava/parser/Java.g:1085:10: selector
10871			    {
10872			    dbg.location(1085,10);
10873			    pushFollow(FOLLOW_selector_in_unaryExpressionNotPlusMinus6199);
10874			    selector();
10875
10876			    state._fsp--;
10877			    if (state.failed) return ;
10878
10879			    }
10880			    break;
10881
10882			default :
10883			    break loop128;
10884                        }
10885                    } while (true);
10886                    } finally {dbg.exitSubRule(128);}
10887
10888                    dbg.location(1087,9);
10889                    // src/com/google/doclava/parser/Java.g:1087:9: ( '++' | '--' )?
10890                    int alt129=2;
10891                    try { dbg.enterSubRule(129);
10892                    try { dbg.enterDecision(129, decisionCanBacktrack[129]);
10893
10894                    int LA129_0 = input.LA(1);
10895
10896                    if ( ((LA129_0>=PLUSPLUS && LA129_0<=SUBSUB)) ) {
10897                        alt129=1;
10898                    }
10899                    } finally {dbg.exitDecision(129);}
10900
10901                    switch (alt129) {
10902                        case 1 :
10903                            dbg.enterAlt(1);
10904
10905                            // src/com/google/doclava/parser/Java.g:
10906                            {
10907                            dbg.location(1087,9);
10908                            if ( (input.LA(1)>=PLUSPLUS && input.LA(1)<=SUBSUB) ) {
10909                                input.consume();
10910                                state.errorRecovery=false;state.failed=false;
10911                            }
10912                            else {
10913                                if (state.backtracking>0) {state.failed=true; return ;}
10914                                MismatchedSetException mse = new MismatchedSetException(null,input);
10915                                dbg.recognitionException(mse);
10916                                throw mse;
10917                            }
10918
10919
10920                            }
10921                            break;
10922
10923                    }
10924                    } finally {dbg.exitSubRule(129);}
10925
10926
10927                    }
10928                    break;
10929
10930            }
10931        }
10932        catch (RecognitionException re) {
10933            reportError(re);
10934            recover(input,re);
10935        }
10936        finally {
10937            if ( state.backtracking>0 ) { memoize(input, 87, unaryExpressionNotPlusMinus_StartIndex); }
10938        }
10939        dbg.location(1090, 5);
10940
10941        }
10942        finally {
10943            dbg.exitRule(getGrammarFileName(), "unaryExpressionNotPlusMinus");
10944            decRuleLevel();
10945            if ( getRuleLevel()==0 ) {dbg.terminate();}
10946        }
10947
10948        return ;
10949    }
10950    // $ANTLR end "unaryExpressionNotPlusMinus"
10951
10952
10953    // $ANTLR start "castExpression"
10954    // src/com/google/doclava/parser/Java.g:1092:1: castExpression : ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus );
10955    public final void castExpression() throws RecognitionException {
10956        int castExpression_StartIndex = input.index();
10957        try { dbg.enterRule(getGrammarFileName(), "castExpression");
10958        if ( getRuleLevel()==0 ) {dbg.commence();}
10959        incRuleLevel();
10960        dbg.location(1092, 1);
10961
10962        try {
10963            if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return ; }
10964            // src/com/google/doclava/parser/Java.g:1093:5: ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus )
10965            int alt131=2;
10966            try { dbg.enterDecision(131, decisionCanBacktrack[131]);
10967
10968            int LA131_0 = input.LA(1);
10969
10970            if ( (LA131_0==LPAREN) ) {
10971                int LA131_1 = input.LA(2);
10972
10973                if ( (synpred206_Java()) ) {
10974                    alt131=1;
10975                }
10976                else if ( (true) ) {
10977                    alt131=2;
10978                }
10979                else {
10980                    if (state.backtracking>0) {state.failed=true; return ;}
10981                    NoViableAltException nvae =
10982                        new NoViableAltException("", 131, 1, input);
10983
10984                    dbg.recognitionException(nvae);
10985                    throw nvae;
10986                }
10987            }
10988            else {
10989                if (state.backtracking>0) {state.failed=true; return ;}
10990                NoViableAltException nvae =
10991                    new NoViableAltException("", 131, 0, input);
10992
10993                dbg.recognitionException(nvae);
10994                throw nvae;
10995            }
10996            } finally {dbg.exitDecision(131);}
10997
10998            switch (alt131) {
10999                case 1 :
11000                    dbg.enterAlt(1);
11001
11002                    // src/com/google/doclava/parser/Java.g:1093:9: '(' primitiveType ')' unaryExpression
11003                    {
11004                    dbg.location(1093,9);
11005                    match(input,LPAREN,FOLLOW_LPAREN_in_castExpression6268); if (state.failed) return ;
11006                    dbg.location(1093,13);
11007                    pushFollow(FOLLOW_primitiveType_in_castExpression6270);
11008                    primitiveType();
11009
11010                    state._fsp--;
11011                    if (state.failed) return ;
11012                    dbg.location(1093,27);
11013                    match(input,RPAREN,FOLLOW_RPAREN_in_castExpression6272); if (state.failed) return ;
11014                    dbg.location(1093,31);
11015                    pushFollow(FOLLOW_unaryExpression_in_castExpression6274);
11016                    unaryExpression();
11017
11018                    state._fsp--;
11019                    if (state.failed) return ;
11020
11021                    }
11022                    break;
11023                case 2 :
11024                    dbg.enterAlt(2);
11025
11026                    // src/com/google/doclava/parser/Java.g:1094:9: '(' type ')' unaryExpressionNotPlusMinus
11027                    {
11028                    dbg.location(1094,9);
11029                    match(input,LPAREN,FOLLOW_LPAREN_in_castExpression6284); if (state.failed) return ;
11030                    dbg.location(1094,13);
11031                    pushFollow(FOLLOW_type_in_castExpression6286);
11032                    type();
11033
11034                    state._fsp--;
11035                    if (state.failed) return ;
11036                    dbg.location(1094,18);
11037                    match(input,RPAREN,FOLLOW_RPAREN_in_castExpression6288); if (state.failed) return ;
11038                    dbg.location(1094,22);
11039                    pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_castExpression6290);
11040                    unaryExpressionNotPlusMinus();
11041
11042                    state._fsp--;
11043                    if (state.failed) return ;
11044
11045                    }
11046                    break;
11047
11048            }
11049        }
11050        catch (RecognitionException re) {
11051            reportError(re);
11052            recover(input,re);
11053        }
11054        finally {
11055            if ( state.backtracking>0 ) { memoize(input, 88, castExpression_StartIndex); }
11056        }
11057        dbg.location(1095, 5);
11058
11059        }
11060        finally {
11061            dbg.exitRule(getGrammarFileName(), "castExpression");
11062            decRuleLevel();
11063            if ( getRuleLevel()==0 ) {dbg.terminate();}
11064        }
11065
11066        return ;
11067    }
11068    // $ANTLR end "castExpression"
11069
11070
11071    // $ANTLR start "primary"
11072    // src/com/google/doclava/parser/Java.g:1097:1: primary : ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' );
11073    public final void primary() throws RecognitionException {
11074        int primary_StartIndex = input.index();
11075        try { dbg.enterRule(getGrammarFileName(), "primary");
11076        if ( getRuleLevel()==0 ) {dbg.commence();}
11077        incRuleLevel();
11078        dbg.location(1097, 1);
11079
11080        try {
11081            if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return ; }
11082            // src/com/google/doclava/parser/Java.g:1101:5: ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' )
11083            int alt137=8;
11084            try { dbg.enterDecision(137, decisionCanBacktrack[137]);
11085
11086            switch ( input.LA(1) ) {
11087            case LPAREN:
11088                {
11089                alt137=1;
11090                }
11091                break;
11092            case THIS:
11093                {
11094                alt137=2;
11095                }
11096                break;
11097            case IDENTIFIER:
11098                {
11099                alt137=3;
11100                }
11101                break;
11102            case SUPER:
11103                {
11104                alt137=4;
11105                }
11106                break;
11107            case INTLITERAL:
11108            case LONGLITERAL:
11109            case FLOATLITERAL:
11110            case DOUBLELITERAL:
11111            case CHARLITERAL:
11112            case STRINGLITERAL:
11113            case TRUE:
11114            case FALSE:
11115            case NULL:
11116                {
11117                alt137=5;
11118                }
11119                break;
11120            case NEW:
11121                {
11122                alt137=6;
11123                }
11124                break;
11125            case BOOLEAN:
11126            case BYTE:
11127            case CHAR:
11128            case DOUBLE:
11129            case FLOAT:
11130            case INT:
11131            case LONG:
11132            case SHORT:
11133                {
11134                alt137=7;
11135                }
11136                break;
11137            case VOID:
11138                {
11139                alt137=8;
11140                }
11141                break;
11142            default:
11143                if (state.backtracking>0) {state.failed=true; return ;}
11144                NoViableAltException nvae =
11145                    new NoViableAltException("", 137, 0, input);
11146
11147                dbg.recognitionException(nvae);
11148                throw nvae;
11149            }
11150
11151            } finally {dbg.exitDecision(137);}
11152
11153            switch (alt137) {
11154                case 1 :
11155                    dbg.enterAlt(1);
11156
11157                    // src/com/google/doclava/parser/Java.g:1101:9: parExpression
11158                    {
11159                    dbg.location(1101,9);
11160                    pushFollow(FOLLOW_parExpression_in_primary6311);
11161                    parExpression();
11162
11163                    state._fsp--;
11164                    if (state.failed) return ;
11165
11166                    }
11167                    break;
11168                case 2 :
11169                    dbg.enterAlt(2);
11170
11171                    // src/com/google/doclava/parser/Java.g:1102:9: 'this' ( '.' IDENTIFIER )* ( identifierSuffix )?
11172                    {
11173                    dbg.location(1102,9);
11174                    match(input,THIS,FOLLOW_THIS_in_primary6321); if (state.failed) return ;
11175                    dbg.location(1103,9);
11176                    // src/com/google/doclava/parser/Java.g:1103:9: ( '.' IDENTIFIER )*
11177                    try { dbg.enterSubRule(132);
11178
11179                    loop132:
11180                    do {
11181                        int alt132=2;
11182                        try { dbg.enterDecision(132, decisionCanBacktrack[132]);
11183
11184                        int LA132_0 = input.LA(1);
11185
11186                        if ( (LA132_0==DOT) ) {
11187                            int LA132_2 = input.LA(2);
11188
11189                            if ( (LA132_2==IDENTIFIER) ) {
11190                                int LA132_3 = input.LA(3);
11191
11192                                if ( (synpred208_Java()) ) {
11193                                    alt132=1;
11194                                }
11195
11196
11197                            }
11198
11199
11200                        }
11201
11202
11203                        } finally {dbg.exitDecision(132);}
11204
11205                        switch (alt132) {
11206			case 1 :
11207			    dbg.enterAlt(1);
11208
11209			    // src/com/google/doclava/parser/Java.g:1103:10: '.' IDENTIFIER
11210			    {
11211			    dbg.location(1103,10);
11212			    match(input,DOT,FOLLOW_DOT_in_primary6332); if (state.failed) return ;
11213			    dbg.location(1103,14);
11214			    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6334); if (state.failed) return ;
11215
11216			    }
11217			    break;
11218
11219			default :
11220			    break loop132;
11221                        }
11222                    } while (true);
11223                    } finally {dbg.exitSubRule(132);}
11224
11225                    dbg.location(1105,9);
11226                    // src/com/google/doclava/parser/Java.g:1105:9: ( identifierSuffix )?
11227                    int alt133=2;
11228                    try { dbg.enterSubRule(133);
11229                    try { dbg.enterDecision(133, decisionCanBacktrack[133]);
11230
11231                    try {
11232                        isCyclicDecision = true;
11233                        alt133 = dfa133.predict(input);
11234                    }
11235                    catch (NoViableAltException nvae) {
11236                        dbg.recognitionException(nvae);
11237                        throw nvae;
11238                    }
11239                    } finally {dbg.exitDecision(133);}
11240
11241                    switch (alt133) {
11242                        case 1 :
11243                            dbg.enterAlt(1);
11244
11245                            // src/com/google/doclava/parser/Java.g:1105:10: identifierSuffix
11246                            {
11247                            dbg.location(1105,10);
11248                            pushFollow(FOLLOW_identifierSuffix_in_primary6356);
11249                            identifierSuffix();
11250
11251                            state._fsp--;
11252                            if (state.failed) return ;
11253
11254                            }
11255                            break;
11256
11257                    }
11258                    } finally {dbg.exitSubRule(133);}
11259
11260
11261                    }
11262                    break;
11263                case 3 :
11264                    dbg.enterAlt(3);
11265
11266                    // src/com/google/doclava/parser/Java.g:1107:9: IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )?
11267                    {
11268                    dbg.location(1107,9);
11269                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6377); if (state.failed) return ;
11270                    dbg.location(1108,9);
11271                    // src/com/google/doclava/parser/Java.g:1108:9: ( '.' IDENTIFIER )*
11272                    try { dbg.enterSubRule(134);
11273
11274                    loop134:
11275                    do {
11276                        int alt134=2;
11277                        try { dbg.enterDecision(134, decisionCanBacktrack[134]);
11278
11279                        int LA134_0 = input.LA(1);
11280
11281                        if ( (LA134_0==DOT) ) {
11282                            int LA134_2 = input.LA(2);
11283
11284                            if ( (LA134_2==IDENTIFIER) ) {
11285                                int LA134_3 = input.LA(3);
11286
11287                                if ( (synpred211_Java()) ) {
11288                                    alt134=1;
11289                                }
11290
11291
11292                            }
11293
11294
11295                        }
11296
11297
11298                        } finally {dbg.exitDecision(134);}
11299
11300                        switch (alt134) {
11301			case 1 :
11302			    dbg.enterAlt(1);
11303
11304			    // src/com/google/doclava/parser/Java.g:1108:10: '.' IDENTIFIER
11305			    {
11306			    dbg.location(1108,10);
11307			    match(input,DOT,FOLLOW_DOT_in_primary6388); if (state.failed) return ;
11308			    dbg.location(1108,14);
11309			    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary6390); if (state.failed) return ;
11310
11311			    }
11312			    break;
11313
11314			default :
11315			    break loop134;
11316                        }
11317                    } while (true);
11318                    } finally {dbg.exitSubRule(134);}
11319
11320                    dbg.location(1110,9);
11321                    // src/com/google/doclava/parser/Java.g:1110:9: ( identifierSuffix )?
11322                    int alt135=2;
11323                    try { dbg.enterSubRule(135);
11324                    try { dbg.enterDecision(135, decisionCanBacktrack[135]);
11325
11326                    try {
11327                        isCyclicDecision = true;
11328                        alt135 = dfa135.predict(input);
11329                    }
11330                    catch (NoViableAltException nvae) {
11331                        dbg.recognitionException(nvae);
11332                        throw nvae;
11333                    }
11334                    } finally {dbg.exitDecision(135);}
11335
11336                    switch (alt135) {
11337                        case 1 :
11338                            dbg.enterAlt(1);
11339
11340                            // src/com/google/doclava/parser/Java.g:1110:10: identifierSuffix
11341                            {
11342                            dbg.location(1110,10);
11343                            pushFollow(FOLLOW_identifierSuffix_in_primary6412);
11344                            identifierSuffix();
11345
11346                            state._fsp--;
11347                            if (state.failed) return ;
11348
11349                            }
11350                            break;
11351
11352                    }
11353                    } finally {dbg.exitSubRule(135);}
11354
11355
11356                    }
11357                    break;
11358                case 4 :
11359                    dbg.enterAlt(4);
11360
11361                    // src/com/google/doclava/parser/Java.g:1112:9: 'super' superSuffix
11362                    {
11363                    dbg.location(1112,9);
11364                    match(input,SUPER,FOLLOW_SUPER_in_primary6433); if (state.failed) return ;
11365                    dbg.location(1113,9);
11366                    pushFollow(FOLLOW_superSuffix_in_primary6443);
11367                    superSuffix();
11368
11369                    state._fsp--;
11370                    if (state.failed) return ;
11371
11372                    }
11373                    break;
11374                case 5 :
11375                    dbg.enterAlt(5);
11376
11377                    // src/com/google/doclava/parser/Java.g:1114:9: literal
11378                    {
11379                    dbg.location(1114,9);
11380                    pushFollow(FOLLOW_literal_in_primary6453);
11381                    literal();
11382
11383                    state._fsp--;
11384                    if (state.failed) return ;
11385
11386                    }
11387                    break;
11388                case 6 :
11389                    dbg.enterAlt(6);
11390
11391                    // src/com/google/doclava/parser/Java.g:1115:9: creator
11392                    {
11393                    dbg.location(1115,9);
11394                    pushFollow(FOLLOW_creator_in_primary6463);
11395                    creator();
11396
11397                    state._fsp--;
11398                    if (state.failed) return ;
11399
11400                    }
11401                    break;
11402                case 7 :
11403                    dbg.enterAlt(7);
11404
11405                    // src/com/google/doclava/parser/Java.g:1116:9: primitiveType ( '[' ']' )* '.' 'class'
11406                    {
11407                    dbg.location(1116,9);
11408                    pushFollow(FOLLOW_primitiveType_in_primary6473);
11409                    primitiveType();
11410
11411                    state._fsp--;
11412                    if (state.failed) return ;
11413                    dbg.location(1117,9);
11414                    // src/com/google/doclava/parser/Java.g:1117:9: ( '[' ']' )*
11415                    try { dbg.enterSubRule(136);
11416
11417                    loop136:
11418                    do {
11419                        int alt136=2;
11420                        try { dbg.enterDecision(136, decisionCanBacktrack[136]);
11421
11422                        int LA136_0 = input.LA(1);
11423
11424                        if ( (LA136_0==LBRACKET) ) {
11425                            alt136=1;
11426                        }
11427
11428
11429                        } finally {dbg.exitDecision(136);}
11430
11431                        switch (alt136) {
11432			case 1 :
11433			    dbg.enterAlt(1);
11434
11435			    // src/com/google/doclava/parser/Java.g:1117:10: '[' ']'
11436			    {
11437			    dbg.location(1117,10);
11438			    match(input,LBRACKET,FOLLOW_LBRACKET_in_primary6484); if (state.failed) return ;
11439			    dbg.location(1117,14);
11440			    match(input,RBRACKET,FOLLOW_RBRACKET_in_primary6486); if (state.failed) return ;
11441
11442			    }
11443			    break;
11444
11445			default :
11446			    break loop136;
11447                        }
11448                    } while (true);
11449                    } finally {dbg.exitSubRule(136);}
11450
11451                    dbg.location(1119,9);
11452                    match(input,DOT,FOLLOW_DOT_in_primary6507); if (state.failed) return ;
11453                    dbg.location(1119,13);
11454                    match(input,CLASS,FOLLOW_CLASS_in_primary6509); if (state.failed) return ;
11455
11456                    }
11457                    break;
11458                case 8 :
11459                    dbg.enterAlt(8);
11460
11461                    // src/com/google/doclava/parser/Java.g:1120:9: 'void' '.' 'class'
11462                    {
11463                    dbg.location(1120,9);
11464                    match(input,VOID,FOLLOW_VOID_in_primary6519); if (state.failed) return ;
11465                    dbg.location(1120,16);
11466                    match(input,DOT,FOLLOW_DOT_in_primary6521); if (state.failed) return ;
11467                    dbg.location(1120,20);
11468                    match(input,CLASS,FOLLOW_CLASS_in_primary6523); if (state.failed) return ;
11469
11470                    }
11471                    break;
11472
11473            }
11474        }
11475        catch (RecognitionException re) {
11476            reportError(re);
11477            recover(input,re);
11478        }
11479        finally {
11480            if ( state.backtracking>0 ) { memoize(input, 89, primary_StartIndex); }
11481        }
11482        dbg.location(1121, 5);
11483
11484        }
11485        finally {
11486            dbg.exitRule(getGrammarFileName(), "primary");
11487            decRuleLevel();
11488            if ( getRuleLevel()==0 ) {dbg.terminate();}
11489        }
11490
11491        return ;
11492    }
11493    // $ANTLR end "primary"
11494
11495
11496    // $ANTLR start "superSuffix"
11497    // src/com/google/doclava/parser/Java.g:1124:1: superSuffix : ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? );
11498    public final void superSuffix() throws RecognitionException {
11499        int superSuffix_StartIndex = input.index();
11500        try { dbg.enterRule(getGrammarFileName(), "superSuffix");
11501        if ( getRuleLevel()==0 ) {dbg.commence();}
11502        incRuleLevel();
11503        dbg.location(1124, 1);
11504
11505        try {
11506            if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return ; }
11507            // src/com/google/doclava/parser/Java.g:1125:5: ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? )
11508            int alt140=2;
11509            try { dbg.enterDecision(140, decisionCanBacktrack[140]);
11510
11511            int LA140_0 = input.LA(1);
11512
11513            if ( (LA140_0==LPAREN) ) {
11514                alt140=1;
11515            }
11516            else if ( (LA140_0==DOT) ) {
11517                alt140=2;
11518            }
11519            else {
11520                if (state.backtracking>0) {state.failed=true; return ;}
11521                NoViableAltException nvae =
11522                    new NoViableAltException("", 140, 0, input);
11523
11524                dbg.recognitionException(nvae);
11525                throw nvae;
11526            }
11527            } finally {dbg.exitDecision(140);}
11528
11529            switch (alt140) {
11530                case 1 :
11531                    dbg.enterAlt(1);
11532
11533                    // src/com/google/doclava/parser/Java.g:1125:9: arguments
11534                    {
11535                    dbg.location(1125,9);
11536                    pushFollow(FOLLOW_arguments_in_superSuffix6543);
11537                    arguments();
11538
11539                    state._fsp--;
11540                    if (state.failed) return ;
11541
11542                    }
11543                    break;
11544                case 2 :
11545                    dbg.enterAlt(2);
11546
11547                    // src/com/google/doclava/parser/Java.g:1126:9: '.' ( typeArguments )? IDENTIFIER ( arguments )?
11548                    {
11549                    dbg.location(1126,9);
11550                    match(input,DOT,FOLLOW_DOT_in_superSuffix6553); if (state.failed) return ;
11551                    dbg.location(1126,13);
11552                    // src/com/google/doclava/parser/Java.g:1126:13: ( typeArguments )?
11553                    int alt138=2;
11554                    try { dbg.enterSubRule(138);
11555                    try { dbg.enterDecision(138, decisionCanBacktrack[138]);
11556
11557                    int LA138_0 = input.LA(1);
11558
11559                    if ( (LA138_0==LT) ) {
11560                        alt138=1;
11561                    }
11562                    } finally {dbg.exitDecision(138);}
11563
11564                    switch (alt138) {
11565                        case 1 :
11566                            dbg.enterAlt(1);
11567
11568                            // src/com/google/doclava/parser/Java.g:1126:14: typeArguments
11569                            {
11570                            dbg.location(1126,14);
11571                            pushFollow(FOLLOW_typeArguments_in_superSuffix6556);
11572                            typeArguments();
11573
11574                            state._fsp--;
11575                            if (state.failed) return ;
11576
11577                            }
11578                            break;
11579
11580                    }
11581                    } finally {dbg.exitSubRule(138);}
11582
11583                    dbg.location(1128,9);
11584                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_superSuffix6577); if (state.failed) return ;
11585                    dbg.location(1129,9);
11586                    // src/com/google/doclava/parser/Java.g:1129:9: ( arguments )?
11587                    int alt139=2;
11588                    try { dbg.enterSubRule(139);
11589                    try { dbg.enterDecision(139, decisionCanBacktrack[139]);
11590
11591                    int LA139_0 = input.LA(1);
11592
11593                    if ( (LA139_0==LPAREN) ) {
11594                        alt139=1;
11595                    }
11596                    } finally {dbg.exitDecision(139);}
11597
11598                    switch (alt139) {
11599                        case 1 :
11600                            dbg.enterAlt(1);
11601
11602                            // src/com/google/doclava/parser/Java.g:1129:10: arguments
11603                            {
11604                            dbg.location(1129,10);
11605                            pushFollow(FOLLOW_arguments_in_superSuffix6588);
11606                            arguments();
11607
11608                            state._fsp--;
11609                            if (state.failed) return ;
11610
11611                            }
11612                            break;
11613
11614                    }
11615                    } finally {dbg.exitSubRule(139);}
11616
11617
11618                    }
11619                    break;
11620
11621            }
11622        }
11623        catch (RecognitionException re) {
11624            reportError(re);
11625            recover(input,re);
11626        }
11627        finally {
11628            if ( state.backtracking>0 ) { memoize(input, 90, superSuffix_StartIndex); }
11629        }
11630        dbg.location(1131, 5);
11631
11632        }
11633        finally {
11634            dbg.exitRule(getGrammarFileName(), "superSuffix");
11635            decRuleLevel();
11636            if ( getRuleLevel()==0 ) {dbg.terminate();}
11637        }
11638
11639        return ;
11640    }
11641    // $ANTLR end "superSuffix"
11642
11643
11644    // $ANTLR start "identifierSuffix"
11645    // src/com/google/doclava/parser/Java.g:1134:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator );
11646    public final void identifierSuffix() throws RecognitionException {
11647        int identifierSuffix_StartIndex = input.index();
11648        try { dbg.enterRule(getGrammarFileName(), "identifierSuffix");
11649        if ( getRuleLevel()==0 ) {dbg.commence();}
11650        incRuleLevel();
11651        dbg.location(1134, 1);
11652
11653        try {
11654            if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return ; }
11655            // src/com/google/doclava/parser/Java.g:1135:5: ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator )
11656            int alt143=8;
11657            try { dbg.enterDecision(143, decisionCanBacktrack[143]);
11658
11659            try {
11660                isCyclicDecision = true;
11661                alt143 = dfa143.predict(input);
11662            }
11663            catch (NoViableAltException nvae) {
11664                dbg.recognitionException(nvae);
11665                throw nvae;
11666            }
11667            } finally {dbg.exitDecision(143);}
11668
11669            switch (alt143) {
11670                case 1 :
11671                    dbg.enterAlt(1);
11672
11673                    // src/com/google/doclava/parser/Java.g:1135:9: ( '[' ']' )+ '.' 'class'
11674                    {
11675                    dbg.location(1135,9);
11676                    // src/com/google/doclava/parser/Java.g:1135:9: ( '[' ']' )+
11677                    int cnt141=0;
11678                    try { dbg.enterSubRule(141);
11679
11680                    loop141:
11681                    do {
11682                        int alt141=2;
11683                        try { dbg.enterDecision(141, decisionCanBacktrack[141]);
11684
11685                        int LA141_0 = input.LA(1);
11686
11687                        if ( (LA141_0==LBRACKET) ) {
11688                            alt141=1;
11689                        }
11690
11691
11692                        } finally {dbg.exitDecision(141);}
11693
11694                        switch (alt141) {
11695			case 1 :
11696			    dbg.enterAlt(1);
11697
11698			    // src/com/google/doclava/parser/Java.g:1135:10: '[' ']'
11699			    {
11700			    dbg.location(1135,10);
11701			    match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix6620); if (state.failed) return ;
11702			    dbg.location(1135,14);
11703			    match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix6622); if (state.failed) return ;
11704
11705			    }
11706			    break;
11707
11708			default :
11709			    if ( cnt141 >= 1 ) break loop141;
11710			    if (state.backtracking>0) {state.failed=true; return ;}
11711                                EarlyExitException eee =
11712                                    new EarlyExitException(141, input);
11713                                dbg.recognitionException(eee);
11714
11715                                throw eee;
11716                        }
11717                        cnt141++;
11718                    } while (true);
11719                    } finally {dbg.exitSubRule(141);}
11720
11721                    dbg.location(1137,9);
11722                    match(input,DOT,FOLLOW_DOT_in_identifierSuffix6643); if (state.failed) return ;
11723                    dbg.location(1137,13);
11724                    match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix6645); if (state.failed) return ;
11725
11726                    }
11727                    break;
11728                case 2 :
11729                    dbg.enterAlt(2);
11730
11731                    // src/com/google/doclava/parser/Java.g:1138:9: ( '[' expression ']' )+
11732                    {
11733                    dbg.location(1138,9);
11734                    // src/com/google/doclava/parser/Java.g:1138:9: ( '[' expression ']' )+
11735                    int cnt142=0;
11736                    try { dbg.enterSubRule(142);
11737
11738                    loop142:
11739                    do {
11740                        int alt142=2;
11741                        try { dbg.enterDecision(142, decisionCanBacktrack[142]);
11742
11743                        try {
11744                            isCyclicDecision = true;
11745                            alt142 = dfa142.predict(input);
11746                        }
11747                        catch (NoViableAltException nvae) {
11748                            dbg.recognitionException(nvae);
11749                            throw nvae;
11750                        }
11751                        } finally {dbg.exitDecision(142);}
11752
11753                        switch (alt142) {
11754			case 1 :
11755			    dbg.enterAlt(1);
11756
11757			    // src/com/google/doclava/parser/Java.g:1138:10: '[' expression ']'
11758			    {
11759			    dbg.location(1138,10);
11760			    match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix6656); if (state.failed) return ;
11761			    dbg.location(1138,14);
11762			    pushFollow(FOLLOW_expression_in_identifierSuffix6658);
11763			    expression();
11764
11765			    state._fsp--;
11766			    if (state.failed) return ;
11767			    dbg.location(1138,25);
11768			    match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix6660); if (state.failed) return ;
11769
11770			    }
11771			    break;
11772
11773			default :
11774			    if ( cnt142 >= 1 ) break loop142;
11775			    if (state.backtracking>0) {state.failed=true; return ;}
11776                                EarlyExitException eee =
11777                                    new EarlyExitException(142, input);
11778                                dbg.recognitionException(eee);
11779
11780                                throw eee;
11781                        }
11782                        cnt142++;
11783                    } while (true);
11784                    } finally {dbg.exitSubRule(142);}
11785
11786
11787                    }
11788                    break;
11789                case 3 :
11790                    dbg.enterAlt(3);
11791
11792                    // src/com/google/doclava/parser/Java.g:1140:9: arguments
11793                    {
11794                    dbg.location(1140,9);
11795                    pushFollow(FOLLOW_arguments_in_identifierSuffix6681);
11796                    arguments();
11797
11798                    state._fsp--;
11799                    if (state.failed) return ;
11800
11801                    }
11802                    break;
11803                case 4 :
11804                    dbg.enterAlt(4);
11805
11806                    // src/com/google/doclava/parser/Java.g:1141:9: '.' 'class'
11807                    {
11808                    dbg.location(1141,9);
11809                    match(input,DOT,FOLLOW_DOT_in_identifierSuffix6691); if (state.failed) return ;
11810                    dbg.location(1141,13);
11811                    match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix6693); if (state.failed) return ;
11812
11813                    }
11814                    break;
11815                case 5 :
11816                    dbg.enterAlt(5);
11817
11818                    // src/com/google/doclava/parser/Java.g:1142:9: '.' nonWildcardTypeArguments IDENTIFIER arguments
11819                    {
11820                    dbg.location(1142,9);
11821                    match(input,DOT,FOLLOW_DOT_in_identifierSuffix6703); if (state.failed) return ;
11822                    dbg.location(1142,13);
11823                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_identifierSuffix6705);
11824                    nonWildcardTypeArguments();
11825
11826                    state._fsp--;
11827                    if (state.failed) return ;
11828                    dbg.location(1142,38);
11829                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifierSuffix6707); if (state.failed) return ;
11830                    dbg.location(1142,49);
11831                    pushFollow(FOLLOW_arguments_in_identifierSuffix6709);
11832                    arguments();
11833
11834                    state._fsp--;
11835                    if (state.failed) return ;
11836
11837                    }
11838                    break;
11839                case 6 :
11840                    dbg.enterAlt(6);
11841
11842                    // src/com/google/doclava/parser/Java.g:1143:9: '.' 'this'
11843                    {
11844                    dbg.location(1143,9);
11845                    match(input,DOT,FOLLOW_DOT_in_identifierSuffix6719); if (state.failed) return ;
11846                    dbg.location(1143,13);
11847                    match(input,THIS,FOLLOW_THIS_in_identifierSuffix6721); if (state.failed) return ;
11848
11849                    }
11850                    break;
11851                case 7 :
11852                    dbg.enterAlt(7);
11853
11854                    // src/com/google/doclava/parser/Java.g:1144:9: '.' 'super' arguments
11855                    {
11856                    dbg.location(1144,9);
11857                    match(input,DOT,FOLLOW_DOT_in_identifierSuffix6731); if (state.failed) return ;
11858                    dbg.location(1144,13);
11859                    match(input,SUPER,FOLLOW_SUPER_in_identifierSuffix6733); if (state.failed) return ;
11860                    dbg.location(1144,21);
11861                    pushFollow(FOLLOW_arguments_in_identifierSuffix6735);
11862                    arguments();
11863
11864                    state._fsp--;
11865                    if (state.failed) return ;
11866
11867                    }
11868                    break;
11869                case 8 :
11870                    dbg.enterAlt(8);
11871
11872                    // src/com/google/doclava/parser/Java.g:1145:9: innerCreator
11873                    {
11874                    dbg.location(1145,9);
11875                    pushFollow(FOLLOW_innerCreator_in_identifierSuffix6745);
11876                    innerCreator();
11877
11878                    state._fsp--;
11879                    if (state.failed) return ;
11880
11881                    }
11882                    break;
11883
11884            }
11885        }
11886        catch (RecognitionException re) {
11887            reportError(re);
11888            recover(input,re);
11889        }
11890        finally {
11891            if ( state.backtracking>0 ) { memoize(input, 91, identifierSuffix_StartIndex); }
11892        }
11893        dbg.location(1146, 5);
11894
11895        }
11896        finally {
11897            dbg.exitRule(getGrammarFileName(), "identifierSuffix");
11898            decRuleLevel();
11899            if ( getRuleLevel()==0 ) {dbg.terminate();}
11900        }
11901
11902        return ;
11903    }
11904    // $ANTLR end "identifierSuffix"
11905
11906
11907    // $ANTLR start "selector"
11908    // src/com/google/doclava/parser/Java.g:1149:1: selector : ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' );
11909    public final void selector() throws RecognitionException {
11910        int selector_StartIndex = input.index();
11911        try { dbg.enterRule(getGrammarFileName(), "selector");
11912        if ( getRuleLevel()==0 ) {dbg.commence();}
11913        incRuleLevel();
11914        dbg.location(1149, 1);
11915
11916        try {
11917            if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return ; }
11918            // src/com/google/doclava/parser/Java.g:1150:5: ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' )
11919            int alt145=5;
11920            try { dbg.enterDecision(145, decisionCanBacktrack[145]);
11921
11922            int LA145_0 = input.LA(1);
11923
11924            if ( (LA145_0==DOT) ) {
11925                switch ( input.LA(2) ) {
11926                case IDENTIFIER:
11927                    {
11928                    alt145=1;
11929                    }
11930                    break;
11931                case THIS:
11932                    {
11933                    alt145=2;
11934                    }
11935                    break;
11936                case SUPER:
11937                    {
11938                    alt145=3;
11939                    }
11940                    break;
11941                case NEW:
11942                    {
11943                    alt145=4;
11944                    }
11945                    break;
11946                default:
11947                    if (state.backtracking>0) {state.failed=true; return ;}
11948                    NoViableAltException nvae =
11949                        new NoViableAltException("", 145, 1, input);
11950
11951                    dbg.recognitionException(nvae);
11952                    throw nvae;
11953                }
11954
11955            }
11956            else if ( (LA145_0==LBRACKET) ) {
11957                alt145=5;
11958            }
11959            else {
11960                if (state.backtracking>0) {state.failed=true; return ;}
11961                NoViableAltException nvae =
11962                    new NoViableAltException("", 145, 0, input);
11963
11964                dbg.recognitionException(nvae);
11965                throw nvae;
11966            }
11967            } finally {dbg.exitDecision(145);}
11968
11969            switch (alt145) {
11970                case 1 :
11971                    dbg.enterAlt(1);
11972
11973                    // src/com/google/doclava/parser/Java.g:1150:9: '.' IDENTIFIER ( arguments )?
11974                    {
11975                    dbg.location(1150,9);
11976                    match(input,DOT,FOLLOW_DOT_in_selector6765); if (state.failed) return ;
11977                    dbg.location(1150,13);
11978                    match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_selector6767); if (state.failed) return ;
11979                    dbg.location(1151,9);
11980                    // src/com/google/doclava/parser/Java.g:1151:9: ( arguments )?
11981                    int alt144=2;
11982                    try { dbg.enterSubRule(144);
11983                    try { dbg.enterDecision(144, decisionCanBacktrack[144]);
11984
11985                    int LA144_0 = input.LA(1);
11986
11987                    if ( (LA144_0==LPAREN) ) {
11988                        alt144=1;
11989                    }
11990                    } finally {dbg.exitDecision(144);}
11991
11992                    switch (alt144) {
11993                        case 1 :
11994                            dbg.enterAlt(1);
11995
11996                            // src/com/google/doclava/parser/Java.g:1151:10: arguments
11997                            {
11998                            dbg.location(1151,10);
11999                            pushFollow(FOLLOW_arguments_in_selector6778);
12000                            arguments();
12001
12002                            state._fsp--;
12003                            if (state.failed) return ;
12004
12005                            }
12006                            break;
12007
12008                    }
12009                    } finally {dbg.exitSubRule(144);}
12010
12011
12012                    }
12013                    break;
12014                case 2 :
12015                    dbg.enterAlt(2);
12016
12017                    // src/com/google/doclava/parser/Java.g:1153:9: '.' 'this'
12018                    {
12019                    dbg.location(1153,9);
12020                    match(input,DOT,FOLLOW_DOT_in_selector6799); if (state.failed) return ;
12021                    dbg.location(1153,13);
12022                    match(input,THIS,FOLLOW_THIS_in_selector6801); if (state.failed) return ;
12023
12024                    }
12025                    break;
12026                case 3 :
12027                    dbg.enterAlt(3);
12028
12029                    // src/com/google/doclava/parser/Java.g:1154:9: '.' 'super' superSuffix
12030                    {
12031                    dbg.location(1154,9);
12032                    match(input,DOT,FOLLOW_DOT_in_selector6811); if (state.failed) return ;
12033                    dbg.location(1154,13);
12034                    match(input,SUPER,FOLLOW_SUPER_in_selector6813); if (state.failed) return ;
12035                    dbg.location(1155,9);
12036                    pushFollow(FOLLOW_superSuffix_in_selector6823);
12037                    superSuffix();
12038
12039                    state._fsp--;
12040                    if (state.failed) return ;
12041
12042                    }
12043                    break;
12044                case 4 :
12045                    dbg.enterAlt(4);
12046
12047                    // src/com/google/doclava/parser/Java.g:1156:9: innerCreator
12048                    {
12049                    dbg.location(1156,9);
12050                    pushFollow(FOLLOW_innerCreator_in_selector6833);
12051                    innerCreator();
12052
12053                    state._fsp--;
12054                    if (state.failed) return ;
12055
12056                    }
12057                    break;
12058                case 5 :
12059                    dbg.enterAlt(5);
12060
12061                    // src/com/google/doclava/parser/Java.g:1157:9: '[' expression ']'
12062                    {
12063                    dbg.location(1157,9);
12064                    match(input,LBRACKET,FOLLOW_LBRACKET_in_selector6843); if (state.failed) return ;
12065                    dbg.location(1157,13);
12066                    pushFollow(FOLLOW_expression_in_selector6845);
12067                    expression();
12068
12069                    state._fsp--;
12070                    if (state.failed) return ;
12071                    dbg.location(1157,24);
12072                    match(input,RBRACKET,FOLLOW_RBRACKET_in_selector6847); if (state.failed) return ;
12073
12074                    }
12075                    break;
12076
12077            }
12078        }
12079        catch (RecognitionException re) {
12080            reportError(re);
12081            recover(input,re);
12082        }
12083        finally {
12084            if ( state.backtracking>0 ) { memoize(input, 92, selector_StartIndex); }
12085        }
12086        dbg.location(1158, 5);
12087
12088        }
12089        finally {
12090            dbg.exitRule(getGrammarFileName(), "selector");
12091            decRuleLevel();
12092            if ( getRuleLevel()==0 ) {dbg.terminate();}
12093        }
12094
12095        return ;
12096    }
12097    // $ANTLR end "selector"
12098
12099
12100    // $ANTLR start "creator"
12101    // src/com/google/doclava/parser/Java.g:1160:1: creator : ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator );
12102    public final void creator() throws RecognitionException {
12103        int creator_StartIndex = input.index();
12104        try { dbg.enterRule(getGrammarFileName(), "creator");
12105        if ( getRuleLevel()==0 ) {dbg.commence();}
12106        incRuleLevel();
12107        dbg.location(1160, 1);
12108
12109        try {
12110            if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return ; }
12111            // src/com/google/doclava/parser/Java.g:1161:5: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator )
12112            int alt146=3;
12113            try { dbg.enterDecision(146, decisionCanBacktrack[146]);
12114
12115            int LA146_0 = input.LA(1);
12116
12117            if ( (LA146_0==NEW) ) {
12118                int LA146_1 = input.LA(2);
12119
12120                if ( (synpred236_Java()) ) {
12121                    alt146=1;
12122                }
12123                else if ( (synpred237_Java()) ) {
12124                    alt146=2;
12125                }
12126                else if ( (true) ) {
12127                    alt146=3;
12128                }
12129                else {
12130                    if (state.backtracking>0) {state.failed=true; return ;}
12131                    NoViableAltException nvae =
12132                        new NoViableAltException("", 146, 1, input);
12133
12134                    dbg.recognitionException(nvae);
12135                    throw nvae;
12136                }
12137            }
12138            else {
12139                if (state.backtracking>0) {state.failed=true; return ;}
12140                NoViableAltException nvae =
12141                    new NoViableAltException("", 146, 0, input);
12142
12143                dbg.recognitionException(nvae);
12144                throw nvae;
12145            }
12146            } finally {dbg.exitDecision(146);}
12147
12148            switch (alt146) {
12149                case 1 :
12150                    dbg.enterAlt(1);
12151
12152                    // src/com/google/doclava/parser/Java.g:1161:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest
12153                    {
12154                    dbg.location(1161,9);
12155                    match(input,NEW,FOLLOW_NEW_in_creator6866); if (state.failed) return ;
12156                    dbg.location(1161,15);
12157                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_creator6868);
12158                    nonWildcardTypeArguments();
12159
12160                    state._fsp--;
12161                    if (state.failed) return ;
12162                    dbg.location(1161,40);
12163                    pushFollow(FOLLOW_classOrInterfaceType_in_creator6870);
12164                    classOrInterfaceType();
12165
12166                    state._fsp--;
12167                    if (state.failed) return ;
12168                    dbg.location(1161,61);
12169                    pushFollow(FOLLOW_classCreatorRest_in_creator6872);
12170                    classCreatorRest();
12171
12172                    state._fsp--;
12173                    if (state.failed) return ;
12174
12175                    }
12176                    break;
12177                case 2 :
12178                    dbg.enterAlt(2);
12179
12180                    // src/com/google/doclava/parser/Java.g:1162:9: 'new' classOrInterfaceType classCreatorRest
12181                    {
12182                    dbg.location(1162,9);
12183                    match(input,NEW,FOLLOW_NEW_in_creator6882); if (state.failed) return ;
12184                    dbg.location(1162,15);
12185                    pushFollow(FOLLOW_classOrInterfaceType_in_creator6884);
12186                    classOrInterfaceType();
12187
12188                    state._fsp--;
12189                    if (state.failed) return ;
12190                    dbg.location(1162,36);
12191                    pushFollow(FOLLOW_classCreatorRest_in_creator6886);
12192                    classCreatorRest();
12193
12194                    state._fsp--;
12195                    if (state.failed) return ;
12196
12197                    }
12198                    break;
12199                case 3 :
12200                    dbg.enterAlt(3);
12201
12202                    // src/com/google/doclava/parser/Java.g:1163:9: arrayCreator
12203                    {
12204                    dbg.location(1163,9);
12205                    pushFollow(FOLLOW_arrayCreator_in_creator6896);
12206                    arrayCreator();
12207
12208                    state._fsp--;
12209                    if (state.failed) return ;
12210
12211                    }
12212                    break;
12213
12214            }
12215        }
12216        catch (RecognitionException re) {
12217            reportError(re);
12218            recover(input,re);
12219        }
12220        finally {
12221            if ( state.backtracking>0 ) { memoize(input, 93, creator_StartIndex); }
12222        }
12223        dbg.location(1164, 5);
12224
12225        }
12226        finally {
12227            dbg.exitRule(getGrammarFileName(), "creator");
12228            decRuleLevel();
12229            if ( getRuleLevel()==0 ) {dbg.terminate();}
12230        }
12231
12232        return ;
12233    }
12234    // $ANTLR end "creator"
12235
12236
12237    // $ANTLR start "arrayCreator"
12238    // src/com/google/doclava/parser/Java.g:1166:1: arrayCreator : ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* );
12239    public final void arrayCreator() throws RecognitionException {
12240        int arrayCreator_StartIndex = input.index();
12241        try { dbg.enterRule(getGrammarFileName(), "arrayCreator");
12242        if ( getRuleLevel()==0 ) {dbg.commence();}
12243        incRuleLevel();
12244        dbg.location(1166, 1);
12245
12246        try {
12247            if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return ; }
12248            // src/com/google/doclava/parser/Java.g:1167:5: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* )
12249            int alt150=2;
12250            try { dbg.enterDecision(150, decisionCanBacktrack[150]);
12251
12252            int LA150_0 = input.LA(1);
12253
12254            if ( (LA150_0==NEW) ) {
12255                int LA150_1 = input.LA(2);
12256
12257                if ( (synpred239_Java()) ) {
12258                    alt150=1;
12259                }
12260                else if ( (true) ) {
12261                    alt150=2;
12262                }
12263                else {
12264                    if (state.backtracking>0) {state.failed=true; return ;}
12265                    NoViableAltException nvae =
12266                        new NoViableAltException("", 150, 1, input);
12267
12268                    dbg.recognitionException(nvae);
12269                    throw nvae;
12270                }
12271            }
12272            else {
12273                if (state.backtracking>0) {state.failed=true; return ;}
12274                NoViableAltException nvae =
12275                    new NoViableAltException("", 150, 0, input);
12276
12277                dbg.recognitionException(nvae);
12278                throw nvae;
12279            }
12280            } finally {dbg.exitDecision(150);}
12281
12282            switch (alt150) {
12283                case 1 :
12284                    dbg.enterAlt(1);
12285
12286                    // src/com/google/doclava/parser/Java.g:1167:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer
12287                    {
12288                    dbg.location(1167,9);
12289                    match(input,NEW,FOLLOW_NEW_in_arrayCreator6915); if (state.failed) return ;
12290                    dbg.location(1167,15);
12291                    pushFollow(FOLLOW_createdName_in_arrayCreator6917);
12292                    createdName();
12293
12294                    state._fsp--;
12295                    if (state.failed) return ;
12296                    dbg.location(1168,9);
12297                    match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6927); if (state.failed) return ;
12298                    dbg.location(1168,13);
12299                    match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6929); if (state.failed) return ;
12300                    dbg.location(1169,9);
12301                    // src/com/google/doclava/parser/Java.g:1169:9: ( '[' ']' )*
12302                    try { dbg.enterSubRule(147);
12303
12304                    loop147:
12305                    do {
12306                        int alt147=2;
12307                        try { dbg.enterDecision(147, decisionCanBacktrack[147]);
12308
12309                        int LA147_0 = input.LA(1);
12310
12311                        if ( (LA147_0==LBRACKET) ) {
12312                            alt147=1;
12313                        }
12314
12315
12316                        } finally {dbg.exitDecision(147);}
12317
12318                        switch (alt147) {
12319			case 1 :
12320			    dbg.enterAlt(1);
12321
12322			    // src/com/google/doclava/parser/Java.g:1169:10: '[' ']'
12323			    {
12324			    dbg.location(1169,10);
12325			    match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6940); if (state.failed) return ;
12326			    dbg.location(1169,14);
12327			    match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6942); if (state.failed) return ;
12328
12329			    }
12330			    break;
12331
12332			default :
12333			    break loop147;
12334                        }
12335                    } while (true);
12336                    } finally {dbg.exitSubRule(147);}
12337
12338                    dbg.location(1171,9);
12339                    pushFollow(FOLLOW_arrayInitializer_in_arrayCreator6963);
12340                    arrayInitializer();
12341
12342                    state._fsp--;
12343                    if (state.failed) return ;
12344
12345                    }
12346                    break;
12347                case 2 :
12348                    dbg.enterAlt(2);
12349
12350                    // src/com/google/doclava/parser/Java.g:1173:9: 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )*
12351                    {
12352                    dbg.location(1173,9);
12353                    match(input,NEW,FOLLOW_NEW_in_arrayCreator6974); if (state.failed) return ;
12354                    dbg.location(1173,15);
12355                    pushFollow(FOLLOW_createdName_in_arrayCreator6976);
12356                    createdName();
12357
12358                    state._fsp--;
12359                    if (state.failed) return ;
12360                    dbg.location(1174,9);
12361                    match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator6986); if (state.failed) return ;
12362                    dbg.location(1174,13);
12363                    pushFollow(FOLLOW_expression_in_arrayCreator6988);
12364                    expression();
12365
12366                    state._fsp--;
12367                    if (state.failed) return ;
12368                    dbg.location(1175,9);
12369                    match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator6998); if (state.failed) return ;
12370                    dbg.location(1176,9);
12371                    // src/com/google/doclava/parser/Java.g:1176:9: ( '[' expression ']' )*
12372                    try { dbg.enterSubRule(148);
12373
12374                    loop148:
12375                    do {
12376                        int alt148=2;
12377                        try { dbg.enterDecision(148, decisionCanBacktrack[148]);
12378
12379                        try {
12380                            isCyclicDecision = true;
12381                            alt148 = dfa148.predict(input);
12382                        }
12383                        catch (NoViableAltException nvae) {
12384                            dbg.recognitionException(nvae);
12385                            throw nvae;
12386                        }
12387                        } finally {dbg.exitDecision(148);}
12388
12389                        switch (alt148) {
12390			case 1 :
12391			    dbg.enterAlt(1);
12392
12393			    // src/com/google/doclava/parser/Java.g:1176:13: '[' expression ']'
12394			    {
12395			    dbg.location(1176,13);
12396			    match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator7012); if (state.failed) return ;
12397			    dbg.location(1176,17);
12398			    pushFollow(FOLLOW_expression_in_arrayCreator7014);
12399			    expression();
12400
12401			    state._fsp--;
12402			    if (state.failed) return ;
12403			    dbg.location(1177,13);
12404			    match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator7028); if (state.failed) return ;
12405
12406			    }
12407			    break;
12408
12409			default :
12410			    break loop148;
12411                        }
12412                    } while (true);
12413                    } finally {dbg.exitSubRule(148);}
12414
12415                    dbg.location(1179,9);
12416                    // src/com/google/doclava/parser/Java.g:1179:9: ( '[' ']' )*
12417                    try { dbg.enterSubRule(149);
12418
12419                    loop149:
12420                    do {
12421                        int alt149=2;
12422                        try { dbg.enterDecision(149, decisionCanBacktrack[149]);
12423
12424                        int LA149_0 = input.LA(1);
12425
12426                        if ( (LA149_0==LBRACKET) ) {
12427                            int LA149_2 = input.LA(2);
12428
12429                            if ( (LA149_2==RBRACKET) ) {
12430                                alt149=1;
12431                            }
12432
12433
12434                        }
12435
12436
12437                        } finally {dbg.exitDecision(149);}
12438
12439                        switch (alt149) {
12440			case 1 :
12441			    dbg.enterAlt(1);
12442
12443			    // src/com/google/doclava/parser/Java.g:1179:10: '[' ']'
12444			    {
12445			    dbg.location(1179,10);
12446			    match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator7050); if (state.failed) return ;
12447			    dbg.location(1179,14);
12448			    match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator7052); if (state.failed) return ;
12449
12450			    }
12451			    break;
12452
12453			default :
12454			    break loop149;
12455                        }
12456                    } while (true);
12457                    } finally {dbg.exitSubRule(149);}
12458
12459
12460                    }
12461                    break;
12462
12463            }
12464        }
12465        catch (RecognitionException re) {
12466            reportError(re);
12467            recover(input,re);
12468        }
12469        finally {
12470            if ( state.backtracking>0 ) { memoize(input, 94, arrayCreator_StartIndex); }
12471        }
12472        dbg.location(1181, 5);
12473
12474        }
12475        finally {
12476            dbg.exitRule(getGrammarFileName(), "arrayCreator");
12477            decRuleLevel();
12478            if ( getRuleLevel()==0 ) {dbg.terminate();}
12479        }
12480
12481        return ;
12482    }
12483    // $ANTLR end "arrayCreator"
12484
12485
12486    // $ANTLR start "variableInitializer"
12487    // src/com/google/doclava/parser/Java.g:1183:1: variableInitializer : ( arrayInitializer | expression );
12488    public final void variableInitializer() throws RecognitionException {
12489        int variableInitializer_StartIndex = input.index();
12490        try { dbg.enterRule(getGrammarFileName(), "variableInitializer");
12491        if ( getRuleLevel()==0 ) {dbg.commence();}
12492        incRuleLevel();
12493        dbg.location(1183, 1);
12494
12495        try {
12496            if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return ; }
12497            // src/com/google/doclava/parser/Java.g:1184:5: ( arrayInitializer | expression )
12498            int alt151=2;
12499            try { dbg.enterDecision(151, decisionCanBacktrack[151]);
12500
12501            int LA151_0 = input.LA(1);
12502
12503            if ( (LA151_0==LBRACE) ) {
12504                alt151=1;
12505            }
12506            else if ( ((LA151_0>=IDENTIFIER && LA151_0<=NULL)||LA151_0==BOOLEAN||LA151_0==BYTE||LA151_0==CHAR||LA151_0==DOUBLE||LA151_0==FLOAT||LA151_0==INT||LA151_0==LONG||LA151_0==NEW||LA151_0==SHORT||LA151_0==SUPER||LA151_0==THIS||LA151_0==VOID||LA151_0==LPAREN||(LA151_0>=BANG && LA151_0<=TILDE)||(LA151_0>=PLUSPLUS && LA151_0<=SUB)) ) {
12507                alt151=2;
12508            }
12509            else {
12510                if (state.backtracking>0) {state.failed=true; return ;}
12511                NoViableAltException nvae =
12512                    new NoViableAltException("", 151, 0, input);
12513
12514                dbg.recognitionException(nvae);
12515                throw nvae;
12516            }
12517            } finally {dbg.exitDecision(151);}
12518
12519            switch (alt151) {
12520                case 1 :
12521                    dbg.enterAlt(1);
12522
12523                    // src/com/google/doclava/parser/Java.g:1184:9: arrayInitializer
12524                    {
12525                    dbg.location(1184,9);
12526                    pushFollow(FOLLOW_arrayInitializer_in_variableInitializer7082);
12527                    arrayInitializer();
12528
12529                    state._fsp--;
12530                    if (state.failed) return ;
12531
12532                    }
12533                    break;
12534                case 2 :
12535                    dbg.enterAlt(2);
12536
12537                    // src/com/google/doclava/parser/Java.g:1185:9: expression
12538                    {
12539                    dbg.location(1185,9);
12540                    pushFollow(FOLLOW_expression_in_variableInitializer7092);
12541                    expression();
12542
12543                    state._fsp--;
12544                    if (state.failed) return ;
12545
12546                    }
12547                    break;
12548
12549            }
12550        }
12551        catch (RecognitionException re) {
12552            reportError(re);
12553            recover(input,re);
12554        }
12555        finally {
12556            if ( state.backtracking>0 ) { memoize(input, 95, variableInitializer_StartIndex); }
12557        }
12558        dbg.location(1186, 5);
12559
12560        }
12561        finally {
12562            dbg.exitRule(getGrammarFileName(), "variableInitializer");
12563            decRuleLevel();
12564            if ( getRuleLevel()==0 ) {dbg.terminate();}
12565        }
12566
12567        return ;
12568    }
12569    // $ANTLR end "variableInitializer"
12570
12571
12572    // $ANTLR start "arrayInitializer"
12573    // src/com/google/doclava/parser/Java.g:1188:1: arrayInitializer : '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' ;
12574    public final void arrayInitializer() throws RecognitionException {
12575        int arrayInitializer_StartIndex = input.index();
12576        try { dbg.enterRule(getGrammarFileName(), "arrayInitializer");
12577        if ( getRuleLevel()==0 ) {dbg.commence();}
12578        incRuleLevel();
12579        dbg.location(1188, 1);
12580
12581        try {
12582            if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return ; }
12583            // src/com/google/doclava/parser/Java.g:1189:5: ( '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' )
12584            dbg.enterAlt(1);
12585
12586            // src/com/google/doclava/parser/Java.g:1189:9: '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}'
12587            {
12588            dbg.location(1189,9);
12589            match(input,LBRACE,FOLLOW_LBRACE_in_arrayInitializer7111); if (state.failed) return ;
12590            dbg.location(1190,13);
12591            // src/com/google/doclava/parser/Java.g:1190:13: ( variableInitializer ( ',' variableInitializer )* )?
12592            int alt153=2;
12593            try { dbg.enterSubRule(153);
12594            try { dbg.enterDecision(153, decisionCanBacktrack[153]);
12595
12596            int LA153_0 = input.LA(1);
12597
12598            if ( ((LA153_0>=IDENTIFIER && LA153_0<=NULL)||LA153_0==BOOLEAN||LA153_0==BYTE||LA153_0==CHAR||LA153_0==DOUBLE||LA153_0==FLOAT||LA153_0==INT||LA153_0==LONG||LA153_0==NEW||LA153_0==SHORT||LA153_0==SUPER||LA153_0==THIS||LA153_0==VOID||LA153_0==LPAREN||LA153_0==LBRACE||(LA153_0>=BANG && LA153_0<=TILDE)||(LA153_0>=PLUSPLUS && LA153_0<=SUB)) ) {
12599                alt153=1;
12600            }
12601            } finally {dbg.exitDecision(153);}
12602
12603            switch (alt153) {
12604                case 1 :
12605                    dbg.enterAlt(1);
12606
12607                    // src/com/google/doclava/parser/Java.g:1190:14: variableInitializer ( ',' variableInitializer )*
12608                    {
12609                    dbg.location(1190,14);
12610                    pushFollow(FOLLOW_variableInitializer_in_arrayInitializer7126);
12611                    variableInitializer();
12612
12613                    state._fsp--;
12614                    if (state.failed) return ;
12615                    dbg.location(1191,17);
12616                    // src/com/google/doclava/parser/Java.g:1191:17: ( ',' variableInitializer )*
12617                    try { dbg.enterSubRule(152);
12618
12619                    loop152:
12620                    do {
12621                        int alt152=2;
12622                        try { dbg.enterDecision(152, decisionCanBacktrack[152]);
12623
12624                        int LA152_0 = input.LA(1);
12625
12626                        if ( (LA152_0==COMMA) ) {
12627                            int LA152_1 = input.LA(2);
12628
12629                            if ( ((LA152_1>=IDENTIFIER && LA152_1<=NULL)||LA152_1==BOOLEAN||LA152_1==BYTE||LA152_1==CHAR||LA152_1==DOUBLE||LA152_1==FLOAT||LA152_1==INT||LA152_1==LONG||LA152_1==NEW||LA152_1==SHORT||LA152_1==SUPER||LA152_1==THIS||LA152_1==VOID||LA152_1==LPAREN||LA152_1==LBRACE||(LA152_1>=BANG && LA152_1<=TILDE)||(LA152_1>=PLUSPLUS && LA152_1<=SUB)) ) {
12630                                alt152=1;
12631                            }
12632
12633
12634                        }
12635
12636
12637                        } finally {dbg.exitDecision(152);}
12638
12639                        switch (alt152) {
12640			case 1 :
12641			    dbg.enterAlt(1);
12642
12643			    // src/com/google/doclava/parser/Java.g:1191:18: ',' variableInitializer
12644			    {
12645			    dbg.location(1191,18);
12646			    match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer7145); if (state.failed) return ;
12647			    dbg.location(1191,22);
12648			    pushFollow(FOLLOW_variableInitializer_in_arrayInitializer7147);
12649			    variableInitializer();
12650
12651			    state._fsp--;
12652			    if (state.failed) return ;
12653
12654			    }
12655			    break;
12656
12657			default :
12658			    break loop152;
12659                        }
12660                    } while (true);
12661                    } finally {dbg.exitSubRule(152);}
12662
12663
12664                    }
12665                    break;
12666
12667            }
12668            } finally {dbg.exitSubRule(153);}
12669
12670            dbg.location(1194,13);
12671            // src/com/google/doclava/parser/Java.g:1194:13: ( ',' )?
12672            int alt154=2;
12673            try { dbg.enterSubRule(154);
12674            try { dbg.enterDecision(154, decisionCanBacktrack[154]);
12675
12676            int LA154_0 = input.LA(1);
12677
12678            if ( (LA154_0==COMMA) ) {
12679                alt154=1;
12680            }
12681            } finally {dbg.exitDecision(154);}
12682
12683            switch (alt154) {
12684                case 1 :
12685                    dbg.enterAlt(1);
12686
12687                    // src/com/google/doclava/parser/Java.g:1194:14: ','
12688                    {
12689                    dbg.location(1194,14);
12690                    match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer7196); if (state.failed) return ;
12691
12692                    }
12693                    break;
12694
12695            }
12696            } finally {dbg.exitSubRule(154);}
12697
12698            dbg.location(1195,9);
12699            match(input,RBRACE,FOLLOW_RBRACE_in_arrayInitializer7208); if (state.failed) return ;
12700
12701            }
12702
12703        }
12704        catch (RecognitionException re) {
12705            reportError(re);
12706            recover(input,re);
12707        }
12708        finally {
12709            if ( state.backtracking>0 ) { memoize(input, 96, arrayInitializer_StartIndex); }
12710        }
12711        dbg.location(1196, 5);
12712
12713        }
12714        finally {
12715            dbg.exitRule(getGrammarFileName(), "arrayInitializer");
12716            decRuleLevel();
12717            if ( getRuleLevel()==0 ) {dbg.terminate();}
12718        }
12719
12720        return ;
12721    }
12722    // $ANTLR end "arrayInitializer"
12723
12724
12725    // $ANTLR start "createdName"
12726    // src/com/google/doclava/parser/Java.g:1199:1: createdName : ( classOrInterfaceType | primitiveType );
12727    public final void createdName() throws RecognitionException {
12728        int createdName_StartIndex = input.index();
12729        try { dbg.enterRule(getGrammarFileName(), "createdName");
12730        if ( getRuleLevel()==0 ) {dbg.commence();}
12731        incRuleLevel();
12732        dbg.location(1199, 1);
12733
12734        try {
12735            if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return ; }
12736            // src/com/google/doclava/parser/Java.g:1200:5: ( classOrInterfaceType | primitiveType )
12737            int alt155=2;
12738            try { dbg.enterDecision(155, decisionCanBacktrack[155]);
12739
12740            int LA155_0 = input.LA(1);
12741
12742            if ( (LA155_0==IDENTIFIER) ) {
12743                alt155=1;
12744            }
12745            else if ( (LA155_0==BOOLEAN||LA155_0==BYTE||LA155_0==CHAR||LA155_0==DOUBLE||LA155_0==FLOAT||LA155_0==INT||LA155_0==LONG||LA155_0==SHORT) ) {
12746                alt155=2;
12747            }
12748            else {
12749                if (state.backtracking>0) {state.failed=true; return ;}
12750                NoViableAltException nvae =
12751                    new NoViableAltException("", 155, 0, input);
12752
12753                dbg.recognitionException(nvae);
12754                throw nvae;
12755            }
12756            } finally {dbg.exitDecision(155);}
12757
12758            switch (alt155) {
12759                case 1 :
12760                    dbg.enterAlt(1);
12761
12762                    // src/com/google/doclava/parser/Java.g:1200:9: classOrInterfaceType
12763                    {
12764                    dbg.location(1200,9);
12765                    pushFollow(FOLLOW_classOrInterfaceType_in_createdName7241);
12766                    classOrInterfaceType();
12767
12768                    state._fsp--;
12769                    if (state.failed) return ;
12770
12771                    }
12772                    break;
12773                case 2 :
12774                    dbg.enterAlt(2);
12775
12776                    // src/com/google/doclava/parser/Java.g:1201:9: primitiveType
12777                    {
12778                    dbg.location(1201,9);
12779                    pushFollow(FOLLOW_primitiveType_in_createdName7251);
12780                    primitiveType();
12781
12782                    state._fsp--;
12783                    if (state.failed) return ;
12784
12785                    }
12786                    break;
12787
12788            }
12789        }
12790        catch (RecognitionException re) {
12791            reportError(re);
12792            recover(input,re);
12793        }
12794        finally {
12795            if ( state.backtracking>0 ) { memoize(input, 97, createdName_StartIndex); }
12796        }
12797        dbg.location(1202, 5);
12798
12799        }
12800        finally {
12801            dbg.exitRule(getGrammarFileName(), "createdName");
12802            decRuleLevel();
12803            if ( getRuleLevel()==0 ) {dbg.terminate();}
12804        }
12805
12806        return ;
12807    }
12808    // $ANTLR end "createdName"
12809
12810
12811    // $ANTLR start "innerCreator"
12812    // src/com/google/doclava/parser/Java.g:1204:1: innerCreator : '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest ;
12813    public final void innerCreator() throws RecognitionException {
12814        int innerCreator_StartIndex = input.index();
12815        try { dbg.enterRule(getGrammarFileName(), "innerCreator");
12816        if ( getRuleLevel()==0 ) {dbg.commence();}
12817        incRuleLevel();
12818        dbg.location(1204, 1);
12819
12820        try {
12821            if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return ; }
12822            // src/com/google/doclava/parser/Java.g:1205:5: ( '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest )
12823            dbg.enterAlt(1);
12824
12825            // src/com/google/doclava/parser/Java.g:1205:9: '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest
12826            {
12827            dbg.location(1205,9);
12828            match(input,DOT,FOLLOW_DOT_in_innerCreator7270); if (state.failed) return ;
12829            dbg.location(1205,13);
12830            match(input,NEW,FOLLOW_NEW_in_innerCreator7272); if (state.failed) return ;
12831            dbg.location(1206,9);
12832            // src/com/google/doclava/parser/Java.g:1206:9: ( nonWildcardTypeArguments )?
12833            int alt156=2;
12834            try { dbg.enterSubRule(156);
12835            try { dbg.enterDecision(156, decisionCanBacktrack[156]);
12836
12837            int LA156_0 = input.LA(1);
12838
12839            if ( (LA156_0==LT) ) {
12840                alt156=1;
12841            }
12842            } finally {dbg.exitDecision(156);}
12843
12844            switch (alt156) {
12845                case 1 :
12846                    dbg.enterAlt(1);
12847
12848                    // src/com/google/doclava/parser/Java.g:1206:10: nonWildcardTypeArguments
12849                    {
12850                    dbg.location(1206,10);
12851                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_innerCreator7283);
12852                    nonWildcardTypeArguments();
12853
12854                    state._fsp--;
12855                    if (state.failed) return ;
12856
12857                    }
12858                    break;
12859
12860            }
12861            } finally {dbg.exitSubRule(156);}
12862
12863            dbg.location(1208,9);
12864            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_innerCreator7304); if (state.failed) return ;
12865            dbg.location(1209,9);
12866            // src/com/google/doclava/parser/Java.g:1209:9: ( typeArguments )?
12867            int alt157=2;
12868            try { dbg.enterSubRule(157);
12869            try { dbg.enterDecision(157, decisionCanBacktrack[157]);
12870
12871            int LA157_0 = input.LA(1);
12872
12873            if ( (LA157_0==LT) ) {
12874                alt157=1;
12875            }
12876            } finally {dbg.exitDecision(157);}
12877
12878            switch (alt157) {
12879                case 1 :
12880                    dbg.enterAlt(1);
12881
12882                    // src/com/google/doclava/parser/Java.g:1209:10: typeArguments
12883                    {
12884                    dbg.location(1209,10);
12885                    pushFollow(FOLLOW_typeArguments_in_innerCreator7315);
12886                    typeArguments();
12887
12888                    state._fsp--;
12889                    if (state.failed) return ;
12890
12891                    }
12892                    break;
12893
12894            }
12895            } finally {dbg.exitSubRule(157);}
12896
12897            dbg.location(1211,9);
12898            pushFollow(FOLLOW_classCreatorRest_in_innerCreator7336);
12899            classCreatorRest();
12900
12901            state._fsp--;
12902            if (state.failed) return ;
12903
12904            }
12905
12906        }
12907        catch (RecognitionException re) {
12908            reportError(re);
12909            recover(input,re);
12910        }
12911        finally {
12912            if ( state.backtracking>0 ) { memoize(input, 98, innerCreator_StartIndex); }
12913        }
12914        dbg.location(1212, 5);
12915
12916        }
12917        finally {
12918            dbg.exitRule(getGrammarFileName(), "innerCreator");
12919            decRuleLevel();
12920            if ( getRuleLevel()==0 ) {dbg.terminate();}
12921        }
12922
12923        return ;
12924    }
12925    // $ANTLR end "innerCreator"
12926
12927
12928    // $ANTLR start "classCreatorRest"
12929    // src/com/google/doclava/parser/Java.g:1215:1: classCreatorRest : arguments ( classBody )? ;
12930    public final void classCreatorRest() throws RecognitionException {
12931        int classCreatorRest_StartIndex = input.index();
12932        try { dbg.enterRule(getGrammarFileName(), "classCreatorRest");
12933        if ( getRuleLevel()==0 ) {dbg.commence();}
12934        incRuleLevel();
12935        dbg.location(1215, 1);
12936
12937        try {
12938            if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return ; }
12939            // src/com/google/doclava/parser/Java.g:1216:5: ( arguments ( classBody )? )
12940            dbg.enterAlt(1);
12941
12942            // src/com/google/doclava/parser/Java.g:1216:9: arguments ( classBody )?
12943            {
12944            dbg.location(1216,9);
12945            pushFollow(FOLLOW_arguments_in_classCreatorRest7356);
12946            arguments();
12947
12948            state._fsp--;
12949            if (state.failed) return ;
12950            dbg.location(1217,9);
12951            // src/com/google/doclava/parser/Java.g:1217:9: ( classBody )?
12952            int alt158=2;
12953            try { dbg.enterSubRule(158);
12954            try { dbg.enterDecision(158, decisionCanBacktrack[158]);
12955
12956            int LA158_0 = input.LA(1);
12957
12958            if ( (LA158_0==LBRACE) ) {
12959                alt158=1;
12960            }
12961            } finally {dbg.exitDecision(158);}
12962
12963            switch (alt158) {
12964                case 1 :
12965                    dbg.enterAlt(1);
12966
12967                    // src/com/google/doclava/parser/Java.g:1217:10: classBody
12968                    {
12969                    dbg.location(1217,10);
12970                    pushFollow(FOLLOW_classBody_in_classCreatorRest7367);
12971                    classBody();
12972
12973                    state._fsp--;
12974                    if (state.failed) return ;
12975
12976                    }
12977                    break;
12978
12979            }
12980            } finally {dbg.exitSubRule(158);}
12981
12982
12983            }
12984
12985        }
12986        catch (RecognitionException re) {
12987            reportError(re);
12988            recover(input,re);
12989        }
12990        finally {
12991            if ( state.backtracking>0 ) { memoize(input, 99, classCreatorRest_StartIndex); }
12992        }
12993        dbg.location(1219, 5);
12994
12995        }
12996        finally {
12997            dbg.exitRule(getGrammarFileName(), "classCreatorRest");
12998            decRuleLevel();
12999            if ( getRuleLevel()==0 ) {dbg.terminate();}
13000        }
13001
13002        return ;
13003    }
13004    // $ANTLR end "classCreatorRest"
13005
13006
13007    // $ANTLR start "nonWildcardTypeArguments"
13008    // src/com/google/doclava/parser/Java.g:1222:1: nonWildcardTypeArguments : '<' typeList '>' ;
13009    public final void nonWildcardTypeArguments() throws RecognitionException {
13010        int nonWildcardTypeArguments_StartIndex = input.index();
13011        try { dbg.enterRule(getGrammarFileName(), "nonWildcardTypeArguments");
13012        if ( getRuleLevel()==0 ) {dbg.commence();}
13013        incRuleLevel();
13014        dbg.location(1222, 1);
13015
13016        try {
13017            if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return ; }
13018            // src/com/google/doclava/parser/Java.g:1223:5: ( '<' typeList '>' )
13019            dbg.enterAlt(1);
13020
13021            // src/com/google/doclava/parser/Java.g:1223:9: '<' typeList '>'
13022            {
13023            dbg.location(1223,9);
13024            match(input,LT,FOLLOW_LT_in_nonWildcardTypeArguments7398); if (state.failed) return ;
13025            dbg.location(1223,13);
13026            pushFollow(FOLLOW_typeList_in_nonWildcardTypeArguments7400);
13027            typeList();
13028
13029            state._fsp--;
13030            if (state.failed) return ;
13031            dbg.location(1224,9);
13032            match(input,GT,FOLLOW_GT_in_nonWildcardTypeArguments7410); if (state.failed) return ;
13033
13034            }
13035
13036        }
13037        catch (RecognitionException re) {
13038            reportError(re);
13039            recover(input,re);
13040        }
13041        finally {
13042            if ( state.backtracking>0 ) { memoize(input, 100, nonWildcardTypeArguments_StartIndex); }
13043        }
13044        dbg.location(1225, 5);
13045
13046        }
13047        finally {
13048            dbg.exitRule(getGrammarFileName(), "nonWildcardTypeArguments");
13049            decRuleLevel();
13050            if ( getRuleLevel()==0 ) {dbg.terminate();}
13051        }
13052
13053        return ;
13054    }
13055    // $ANTLR end "nonWildcardTypeArguments"
13056
13057
13058    // $ANTLR start "arguments"
13059    // src/com/google/doclava/parser/Java.g:1227:1: arguments : '(' ( expressionList )? ')' ;
13060    public final void arguments() throws RecognitionException {
13061        int arguments_StartIndex = input.index();
13062        try { dbg.enterRule(getGrammarFileName(), "arguments");
13063        if ( getRuleLevel()==0 ) {dbg.commence();}
13064        incRuleLevel();
13065        dbg.location(1227, 1);
13066
13067        try {
13068            if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return ; }
13069            // src/com/google/doclava/parser/Java.g:1228:5: ( '(' ( expressionList )? ')' )
13070            dbg.enterAlt(1);
13071
13072            // src/com/google/doclava/parser/Java.g:1228:9: '(' ( expressionList )? ')'
13073            {
13074            dbg.location(1228,9);
13075            match(input,LPAREN,FOLLOW_LPAREN_in_arguments7429); if (state.failed) return ;
13076            dbg.location(1228,13);
13077            // src/com/google/doclava/parser/Java.g:1228:13: ( expressionList )?
13078            int alt159=2;
13079            try { dbg.enterSubRule(159);
13080            try { dbg.enterDecision(159, decisionCanBacktrack[159]);
13081
13082            int LA159_0 = input.LA(1);
13083
13084            if ( ((LA159_0>=IDENTIFIER && LA159_0<=NULL)||LA159_0==BOOLEAN||LA159_0==BYTE||LA159_0==CHAR||LA159_0==DOUBLE||LA159_0==FLOAT||LA159_0==INT||LA159_0==LONG||LA159_0==NEW||LA159_0==SHORT||LA159_0==SUPER||LA159_0==THIS||LA159_0==VOID||LA159_0==LPAREN||(LA159_0>=BANG && LA159_0<=TILDE)||(LA159_0>=PLUSPLUS && LA159_0<=SUB)) ) {
13085                alt159=1;
13086            }
13087            } finally {dbg.exitDecision(159);}
13088
13089            switch (alt159) {
13090                case 1 :
13091                    dbg.enterAlt(1);
13092
13093                    // src/com/google/doclava/parser/Java.g:1228:14: expressionList
13094                    {
13095                    dbg.location(1228,14);
13096                    pushFollow(FOLLOW_expressionList_in_arguments7432);
13097                    expressionList();
13098
13099                    state._fsp--;
13100                    if (state.failed) return ;
13101
13102                    }
13103                    break;
13104
13105            }
13106            } finally {dbg.exitSubRule(159);}
13107
13108            dbg.location(1229,12);
13109            match(input,RPAREN,FOLLOW_RPAREN_in_arguments7445); if (state.failed) return ;
13110
13111            }
13112
13113        }
13114        catch (RecognitionException re) {
13115            reportError(re);
13116            recover(input,re);
13117        }
13118        finally {
13119            if ( state.backtracking>0 ) { memoize(input, 101, arguments_StartIndex); }
13120        }
13121        dbg.location(1230, 5);
13122
13123        }
13124        finally {
13125            dbg.exitRule(getGrammarFileName(), "arguments");
13126            decRuleLevel();
13127            if ( getRuleLevel()==0 ) {dbg.terminate();}
13128        }
13129
13130        return ;
13131    }
13132    // $ANTLR end "arguments"
13133
13134
13135    // $ANTLR start "literal"
13136    // src/com/google/doclava/parser/Java.g:1232:1: literal : ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL );
13137    public final void literal() throws RecognitionException {
13138        int literal_StartIndex = input.index();
13139        try { dbg.enterRule(getGrammarFileName(), "literal");
13140        if ( getRuleLevel()==0 ) {dbg.commence();}
13141        incRuleLevel();
13142        dbg.location(1232, 1);
13143
13144        try {
13145            if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return ; }
13146            // src/com/google/doclava/parser/Java.g:1233:5: ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL )
13147            dbg.enterAlt(1);
13148
13149            // src/com/google/doclava/parser/Java.g:
13150            {
13151            dbg.location(1233,5);
13152            if ( (input.LA(1)>=INTLITERAL && input.LA(1)<=NULL) ) {
13153                input.consume();
13154                state.errorRecovery=false;state.failed=false;
13155            }
13156            else {
13157                if (state.backtracking>0) {state.failed=true; return ;}
13158                MismatchedSetException mse = new MismatchedSetException(null,input);
13159                dbg.recognitionException(mse);
13160                throw mse;
13161            }
13162
13163
13164            }
13165
13166        }
13167        catch (RecognitionException re) {
13168            reportError(re);
13169            recover(input,re);
13170        }
13171        finally {
13172            if ( state.backtracking>0 ) { memoize(input, 102, literal_StartIndex); }
13173        }
13174        dbg.location(1242, 5);
13175
13176        }
13177        finally {
13178            dbg.exitRule(getGrammarFileName(), "literal");
13179            decRuleLevel();
13180            if ( getRuleLevel()==0 ) {dbg.terminate();}
13181        }
13182
13183        return ;
13184    }
13185    // $ANTLR end "literal"
13186
13187
13188    // $ANTLR start "classHeader"
13189    // src/com/google/doclava/parser/Java.g:1244:1: classHeader : modifiers 'class' IDENTIFIER ;
13190    public final void classHeader() throws RecognitionException {
13191        int classHeader_StartIndex = input.index();
13192        try { dbg.enterRule(getGrammarFileName(), "classHeader");
13193        if ( getRuleLevel()==0 ) {dbg.commence();}
13194        incRuleLevel();
13195        dbg.location(1244, 1);
13196
13197        try {
13198            if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return ; }
13199            // src/com/google/doclava/parser/Java.g:1249:5: ( modifiers 'class' IDENTIFIER )
13200            dbg.enterAlt(1);
13201
13202            // src/com/google/doclava/parser/Java.g:1249:9: modifiers 'class' IDENTIFIER
13203            {
13204            dbg.location(1249,9);
13205            pushFollow(FOLLOW_modifiers_in_classHeader7566);
13206            modifiers();
13207
13208            state._fsp--;
13209            if (state.failed) return ;
13210            dbg.location(1249,19);
13211            match(input,CLASS,FOLLOW_CLASS_in_classHeader7568); if (state.failed) return ;
13212            dbg.location(1249,27);
13213            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classHeader7570); if (state.failed) return ;
13214
13215            }
13216
13217        }
13218        catch (RecognitionException re) {
13219            reportError(re);
13220            recover(input,re);
13221        }
13222        finally {
13223            if ( state.backtracking>0 ) { memoize(input, 103, classHeader_StartIndex); }
13224        }
13225        dbg.location(1250, 5);
13226
13227        }
13228        finally {
13229            dbg.exitRule(getGrammarFileName(), "classHeader");
13230            decRuleLevel();
13231            if ( getRuleLevel()==0 ) {dbg.terminate();}
13232        }
13233
13234        return ;
13235    }
13236    // $ANTLR end "classHeader"
13237
13238
13239    // $ANTLR start "enumHeader"
13240    // src/com/google/doclava/parser/Java.g:1252:1: enumHeader : modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER ;
13241    public final void enumHeader() throws RecognitionException {
13242        int enumHeader_StartIndex = input.index();
13243        try { dbg.enterRule(getGrammarFileName(), "enumHeader");
13244        if ( getRuleLevel()==0 ) {dbg.commence();}
13245        incRuleLevel();
13246        dbg.location(1252, 1);
13247
13248        try {
13249            if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return ; }
13250            // src/com/google/doclava/parser/Java.g:1253:5: ( modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER )
13251            dbg.enterAlt(1);
13252
13253            // src/com/google/doclava/parser/Java.g:1253:9: modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER
13254            {
13255            dbg.location(1253,9);
13256            pushFollow(FOLLOW_modifiers_in_enumHeader7589);
13257            modifiers();
13258
13259            state._fsp--;
13260            if (state.failed) return ;
13261            dbg.location(1253,19);
13262            if ( input.LA(1)==IDENTIFIER||input.LA(1)==ENUM ) {
13263                input.consume();
13264                state.errorRecovery=false;state.failed=false;
13265            }
13266            else {
13267                if (state.backtracking>0) {state.failed=true; return ;}
13268                MismatchedSetException mse = new MismatchedSetException(null,input);
13269                dbg.recognitionException(mse);
13270                throw mse;
13271            }
13272
13273            dbg.location(1253,39);
13274            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumHeader7597); if (state.failed) return ;
13275
13276            }
13277
13278        }
13279        catch (RecognitionException re) {
13280            reportError(re);
13281            recover(input,re);
13282        }
13283        finally {
13284            if ( state.backtracking>0 ) { memoize(input, 104, enumHeader_StartIndex); }
13285        }
13286        dbg.location(1254, 5);
13287
13288        }
13289        finally {
13290            dbg.exitRule(getGrammarFileName(), "enumHeader");
13291            decRuleLevel();
13292            if ( getRuleLevel()==0 ) {dbg.terminate();}
13293        }
13294
13295        return ;
13296    }
13297    // $ANTLR end "enumHeader"
13298
13299
13300    // $ANTLR start "interfaceHeader"
13301    // src/com/google/doclava/parser/Java.g:1256:1: interfaceHeader : modifiers 'interface' IDENTIFIER ;
13302    public final void interfaceHeader() throws RecognitionException {
13303        int interfaceHeader_StartIndex = input.index();
13304        try { dbg.enterRule(getGrammarFileName(), "interfaceHeader");
13305        if ( getRuleLevel()==0 ) {dbg.commence();}
13306        incRuleLevel();
13307        dbg.location(1256, 1);
13308
13309        try {
13310            if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return ; }
13311            // src/com/google/doclava/parser/Java.g:1257:5: ( modifiers 'interface' IDENTIFIER )
13312            dbg.enterAlt(1);
13313
13314            // src/com/google/doclava/parser/Java.g:1257:9: modifiers 'interface' IDENTIFIER
13315            {
13316            dbg.location(1257,9);
13317            pushFollow(FOLLOW_modifiers_in_interfaceHeader7616);
13318            modifiers();
13319
13320            state._fsp--;
13321            if (state.failed) return ;
13322            dbg.location(1257,19);
13323            match(input,INTERFACE,FOLLOW_INTERFACE_in_interfaceHeader7618); if (state.failed) return ;
13324            dbg.location(1257,31);
13325            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceHeader7620); if (state.failed) return ;
13326
13327            }
13328
13329        }
13330        catch (RecognitionException re) {
13331            reportError(re);
13332            recover(input,re);
13333        }
13334        finally {
13335            if ( state.backtracking>0 ) { memoize(input, 105, interfaceHeader_StartIndex); }
13336        }
13337        dbg.location(1258, 5);
13338
13339        }
13340        finally {
13341            dbg.exitRule(getGrammarFileName(), "interfaceHeader");
13342            decRuleLevel();
13343            if ( getRuleLevel()==0 ) {dbg.terminate();}
13344        }
13345
13346        return ;
13347    }
13348    // $ANTLR end "interfaceHeader"
13349
13350
13351    // $ANTLR start "annotationHeader"
13352    // src/com/google/doclava/parser/Java.g:1260:1: annotationHeader : modifiers '@' 'interface' IDENTIFIER ;
13353    public final void annotationHeader() throws RecognitionException {
13354        int annotationHeader_StartIndex = input.index();
13355        try { dbg.enterRule(getGrammarFileName(), "annotationHeader");
13356        if ( getRuleLevel()==0 ) {dbg.commence();}
13357        incRuleLevel();
13358        dbg.location(1260, 1);
13359
13360        try {
13361            if ( state.backtracking>0 && alreadyParsedRule(input, 106) ) { return ; }
13362            // src/com/google/doclava/parser/Java.g:1261:5: ( modifiers '@' 'interface' IDENTIFIER )
13363            dbg.enterAlt(1);
13364
13365            // src/com/google/doclava/parser/Java.g:1261:9: modifiers '@' 'interface' IDENTIFIER
13366            {
13367            dbg.location(1261,9);
13368            pushFollow(FOLLOW_modifiers_in_annotationHeader7639);
13369            modifiers();
13370
13371            state._fsp--;
13372            if (state.failed) return ;
13373            dbg.location(1261,19);
13374            match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationHeader7641); if (state.failed) return ;
13375            dbg.location(1261,23);
13376            match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationHeader7643); if (state.failed) return ;
13377            dbg.location(1261,35);
13378            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationHeader7645); if (state.failed) return ;
13379
13380            }
13381
13382        }
13383        catch (RecognitionException re) {
13384            reportError(re);
13385            recover(input,re);
13386        }
13387        finally {
13388            if ( state.backtracking>0 ) { memoize(input, 106, annotationHeader_StartIndex); }
13389        }
13390        dbg.location(1262, 5);
13391
13392        }
13393        finally {
13394            dbg.exitRule(getGrammarFileName(), "annotationHeader");
13395            decRuleLevel();
13396            if ( getRuleLevel()==0 ) {dbg.terminate();}
13397        }
13398
13399        return ;
13400    }
13401    // $ANTLR end "annotationHeader"
13402
13403
13404    // $ANTLR start "typeHeader"
13405    // src/com/google/doclava/parser/Java.g:1264:1: typeHeader : modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER ;
13406    public final void typeHeader() throws RecognitionException {
13407        int typeHeader_StartIndex = input.index();
13408        try { dbg.enterRule(getGrammarFileName(), "typeHeader");
13409        if ( getRuleLevel()==0 ) {dbg.commence();}
13410        incRuleLevel();
13411        dbg.location(1264, 1);
13412
13413        try {
13414            if ( state.backtracking>0 && alreadyParsedRule(input, 107) ) { return ; }
13415            // src/com/google/doclava/parser/Java.g:1265:5: ( modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER )
13416            dbg.enterAlt(1);
13417
13418            // src/com/google/doclava/parser/Java.g:1265:9: modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER
13419            {
13420            dbg.location(1265,9);
13421            pushFollow(FOLLOW_modifiers_in_typeHeader7664);
13422            modifiers();
13423
13424            state._fsp--;
13425            if (state.failed) return ;
13426            dbg.location(1265,19);
13427            // src/com/google/doclava/parser/Java.g:1265:19: ( 'class' | 'enum' | ( ( '@' )? 'interface' ) )
13428            int alt161=3;
13429            try { dbg.enterSubRule(161);
13430            try { dbg.enterDecision(161, decisionCanBacktrack[161]);
13431
13432            switch ( input.LA(1) ) {
13433            case CLASS:
13434                {
13435                alt161=1;
13436                }
13437                break;
13438            case ENUM:
13439                {
13440                alt161=2;
13441                }
13442                break;
13443            case INTERFACE:
13444            case MONKEYS_AT:
13445                {
13446                alt161=3;
13447                }
13448                break;
13449            default:
13450                if (state.backtracking>0) {state.failed=true; return ;}
13451                NoViableAltException nvae =
13452                    new NoViableAltException("", 161, 0, input);
13453
13454                dbg.recognitionException(nvae);
13455                throw nvae;
13456            }
13457
13458            } finally {dbg.exitDecision(161);}
13459
13460            switch (alt161) {
13461                case 1 :
13462                    dbg.enterAlt(1);
13463
13464                    // src/com/google/doclava/parser/Java.g:1265:20: 'class'
13465                    {
13466                    dbg.location(1265,20);
13467                    match(input,CLASS,FOLLOW_CLASS_in_typeHeader7667); if (state.failed) return ;
13468
13469                    }
13470                    break;
13471                case 2 :
13472                    dbg.enterAlt(2);
13473
13474                    // src/com/google/doclava/parser/Java.g:1265:28: 'enum'
13475                    {
13476                    dbg.location(1265,28);
13477                    match(input,ENUM,FOLLOW_ENUM_in_typeHeader7669); if (state.failed) return ;
13478
13479                    }
13480                    break;
13481                case 3 :
13482                    dbg.enterAlt(3);
13483
13484                    // src/com/google/doclava/parser/Java.g:1265:35: ( ( '@' )? 'interface' )
13485                    {
13486                    dbg.location(1265,35);
13487                    // src/com/google/doclava/parser/Java.g:1265:35: ( ( '@' )? 'interface' )
13488                    dbg.enterAlt(1);
13489
13490                    // src/com/google/doclava/parser/Java.g:1265:36: ( '@' )? 'interface'
13491                    {
13492                    dbg.location(1265,36);
13493                    // src/com/google/doclava/parser/Java.g:1265:36: ( '@' )?
13494                    int alt160=2;
13495                    try { dbg.enterSubRule(160);
13496                    try { dbg.enterDecision(160, decisionCanBacktrack[160]);
13497
13498                    int LA160_0 = input.LA(1);
13499
13500                    if ( (LA160_0==MONKEYS_AT) ) {
13501                        alt160=1;
13502                    }
13503                    } finally {dbg.exitDecision(160);}
13504
13505                    switch (alt160) {
13506                        case 1 :
13507                            dbg.enterAlt(1);
13508
13509                            // src/com/google/doclava/parser/Java.g:0:0: '@'
13510                            {
13511                            dbg.location(1265,36);
13512                            match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_typeHeader7672); if (state.failed) return ;
13513
13514                            }
13515                            break;
13516
13517                    }
13518                    } finally {dbg.exitSubRule(160);}
13519
13520                    dbg.location(1265,42);
13521                    match(input,INTERFACE,FOLLOW_INTERFACE_in_typeHeader7676); if (state.failed) return ;
13522
13523                    }
13524
13525
13526                    }
13527                    break;
13528
13529            }
13530            } finally {dbg.exitSubRule(161);}
13531
13532            dbg.location(1265,56);
13533            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeHeader7680); if (state.failed) return ;
13534
13535            }
13536
13537        }
13538        catch (RecognitionException re) {
13539            reportError(re);
13540            recover(input,re);
13541        }
13542        finally {
13543            if ( state.backtracking>0 ) { memoize(input, 107, typeHeader_StartIndex); }
13544        }
13545        dbg.location(1266, 5);
13546
13547        }
13548        finally {
13549            dbg.exitRule(getGrammarFileName(), "typeHeader");
13550            decRuleLevel();
13551            if ( getRuleLevel()==0 ) {dbg.terminate();}
13552        }
13553
13554        return ;
13555    }
13556    // $ANTLR end "typeHeader"
13557
13558
13559    // $ANTLR start "methodHeader"
13560    // src/com/google/doclava/parser/Java.g:1268:1: methodHeader : modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' ;
13561    public final void methodHeader() throws RecognitionException {
13562        int methodHeader_StartIndex = input.index();
13563        try { dbg.enterRule(getGrammarFileName(), "methodHeader");
13564        if ( getRuleLevel()==0 ) {dbg.commence();}
13565        incRuleLevel();
13566        dbg.location(1268, 1);
13567
13568        try {
13569            if ( state.backtracking>0 && alreadyParsedRule(input, 108) ) { return ; }
13570            // src/com/google/doclava/parser/Java.g:1269:5: ( modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' )
13571            dbg.enterAlt(1);
13572
13573            // src/com/google/doclava/parser/Java.g:1269:9: modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '('
13574            {
13575            dbg.location(1269,9);
13576            pushFollow(FOLLOW_modifiers_in_methodHeader7699);
13577            modifiers();
13578
13579            state._fsp--;
13580            if (state.failed) return ;
13581            dbg.location(1269,19);
13582            // src/com/google/doclava/parser/Java.g:1269:19: ( typeParameters )?
13583            int alt162=2;
13584            try { dbg.enterSubRule(162);
13585            try { dbg.enterDecision(162, decisionCanBacktrack[162]);
13586
13587            int LA162_0 = input.LA(1);
13588
13589            if ( (LA162_0==LT) ) {
13590                alt162=1;
13591            }
13592            } finally {dbg.exitDecision(162);}
13593
13594            switch (alt162) {
13595                case 1 :
13596                    dbg.enterAlt(1);
13597
13598                    // src/com/google/doclava/parser/Java.g:0:0: typeParameters
13599                    {
13600                    dbg.location(1269,19);
13601                    pushFollow(FOLLOW_typeParameters_in_methodHeader7701);
13602                    typeParameters();
13603
13604                    state._fsp--;
13605                    if (state.failed) return ;
13606
13607                    }
13608                    break;
13609
13610            }
13611            } finally {dbg.exitSubRule(162);}
13612
13613            dbg.location(1269,35);
13614            // src/com/google/doclava/parser/Java.g:1269:35: ( type | 'void' )?
13615            int alt163=3;
13616            try { dbg.enterSubRule(163);
13617            try { dbg.enterDecision(163, decisionCanBacktrack[163]);
13618
13619            switch ( input.LA(1) ) {
13620                case IDENTIFIER:
13621                    {
13622                    int LA163_1 = input.LA(2);
13623
13624                    if ( (LA163_1==IDENTIFIER||LA163_1==LBRACKET||LA163_1==DOT||LA163_1==LT) ) {
13625                        alt163=1;
13626                    }
13627                    }
13628                    break;
13629                case BOOLEAN:
13630                case BYTE:
13631                case CHAR:
13632                case DOUBLE:
13633                case FLOAT:
13634                case INT:
13635                case LONG:
13636                case SHORT:
13637                    {
13638                    alt163=1;
13639                    }
13640                    break;
13641                case VOID:
13642                    {
13643                    alt163=2;
13644                    }
13645                    break;
13646            }
13647
13648            } finally {dbg.exitDecision(163);}
13649
13650            switch (alt163) {
13651                case 1 :
13652                    dbg.enterAlt(1);
13653
13654                    // src/com/google/doclava/parser/Java.g:1269:36: type
13655                    {
13656                    dbg.location(1269,36);
13657                    pushFollow(FOLLOW_type_in_methodHeader7705);
13658                    type();
13659
13660                    state._fsp--;
13661                    if (state.failed) return ;
13662
13663                    }
13664                    break;
13665                case 2 :
13666                    dbg.enterAlt(2);
13667
13668                    // src/com/google/doclava/parser/Java.g:1269:41: 'void'
13669                    {
13670                    dbg.location(1269,41);
13671                    match(input,VOID,FOLLOW_VOID_in_methodHeader7707); if (state.failed) return ;
13672
13673                    }
13674                    break;
13675
13676            }
13677            } finally {dbg.exitSubRule(163);}
13678
13679            dbg.location(1269,50);
13680            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodHeader7711); if (state.failed) return ;
13681            dbg.location(1269,61);
13682            match(input,LPAREN,FOLLOW_LPAREN_in_methodHeader7713); if (state.failed) return ;
13683
13684            }
13685
13686        }
13687        catch (RecognitionException re) {
13688            reportError(re);
13689            recover(input,re);
13690        }
13691        finally {
13692            if ( state.backtracking>0 ) { memoize(input, 108, methodHeader_StartIndex); }
13693        }
13694        dbg.location(1270, 5);
13695
13696        }
13697        finally {
13698            dbg.exitRule(getGrammarFileName(), "methodHeader");
13699            decRuleLevel();
13700            if ( getRuleLevel()==0 ) {dbg.terminate();}
13701        }
13702
13703        return ;
13704    }
13705    // $ANTLR end "methodHeader"
13706
13707
13708    // $ANTLR start "fieldHeader"
13709    // src/com/google/doclava/parser/Java.g:1272:1: fieldHeader : modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ;
13710    public final void fieldHeader() throws RecognitionException {
13711        int fieldHeader_StartIndex = input.index();
13712        try { dbg.enterRule(getGrammarFileName(), "fieldHeader");
13713        if ( getRuleLevel()==0 ) {dbg.commence();}
13714        incRuleLevel();
13715        dbg.location(1272, 1);
13716
13717        try {
13718            if ( state.backtracking>0 && alreadyParsedRule(input, 109) ) { return ; }
13719            // src/com/google/doclava/parser/Java.g:1273:5: ( modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) )
13720            dbg.enterAlt(1);
13721
13722            // src/com/google/doclava/parser/Java.g:1273:9: modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' )
13723            {
13724            dbg.location(1273,9);
13725            pushFollow(FOLLOW_modifiers_in_fieldHeader7732);
13726            modifiers();
13727
13728            state._fsp--;
13729            if (state.failed) return ;
13730            dbg.location(1273,19);
13731            pushFollow(FOLLOW_type_in_fieldHeader7734);
13732            type();
13733
13734            state._fsp--;
13735            if (state.failed) return ;
13736            dbg.location(1273,24);
13737            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_fieldHeader7736); if (state.failed) return ;
13738            dbg.location(1273,35);
13739            // src/com/google/doclava/parser/Java.g:1273:35: ( '[' ']' )*
13740            try { dbg.enterSubRule(164);
13741
13742            loop164:
13743            do {
13744                int alt164=2;
13745                try { dbg.enterDecision(164, decisionCanBacktrack[164]);
13746
13747                int LA164_0 = input.LA(1);
13748
13749                if ( (LA164_0==LBRACKET) ) {
13750                    alt164=1;
13751                }
13752
13753
13754                } finally {dbg.exitDecision(164);}
13755
13756                switch (alt164) {
13757		case 1 :
13758		    dbg.enterAlt(1);
13759
13760		    // src/com/google/doclava/parser/Java.g:1273:36: '[' ']'
13761		    {
13762		    dbg.location(1273,36);
13763		    match(input,LBRACKET,FOLLOW_LBRACKET_in_fieldHeader7739); if (state.failed) return ;
13764		    dbg.location(1273,39);
13765		    match(input,RBRACKET,FOLLOW_RBRACKET_in_fieldHeader7740); if (state.failed) return ;
13766
13767		    }
13768		    break;
13769
13770		default :
13771		    break loop164;
13772                }
13773            } while (true);
13774            } finally {dbg.exitSubRule(164);}
13775
13776            dbg.location(1273,45);
13777            if ( (input.LA(1)>=SEMI && input.LA(1)<=COMMA)||input.LA(1)==EQ ) {
13778                input.consume();
13779                state.errorRecovery=false;state.failed=false;
13780            }
13781            else {
13782                if (state.backtracking>0) {state.failed=true; return ;}
13783                MismatchedSetException mse = new MismatchedSetException(null,input);
13784                dbg.recognitionException(mse);
13785                throw mse;
13786            }
13787
13788
13789            }
13790
13791        }
13792        catch (RecognitionException re) {
13793            reportError(re);
13794            recover(input,re);
13795        }
13796        finally {
13797            if ( state.backtracking>0 ) { memoize(input, 109, fieldHeader_StartIndex); }
13798        }
13799        dbg.location(1274, 5);
13800
13801        }
13802        finally {
13803            dbg.exitRule(getGrammarFileName(), "fieldHeader");
13804            decRuleLevel();
13805            if ( getRuleLevel()==0 ) {dbg.terminate();}
13806        }
13807
13808        return ;
13809    }
13810    // $ANTLR end "fieldHeader"
13811
13812
13813    // $ANTLR start "localVariableHeader"
13814    // src/com/google/doclava/parser/Java.g:1276:1: localVariableHeader : variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ;
13815    public final void localVariableHeader() throws RecognitionException {
13816        int localVariableHeader_StartIndex = input.index();
13817        try { dbg.enterRule(getGrammarFileName(), "localVariableHeader");
13818        if ( getRuleLevel()==0 ) {dbg.commence();}
13819        incRuleLevel();
13820        dbg.location(1276, 1);
13821
13822        try {
13823            if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return ; }
13824            // src/com/google/doclava/parser/Java.g:1277:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) )
13825            dbg.enterAlt(1);
13826
13827            // src/com/google/doclava/parser/Java.g:1277:9: variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' )
13828            {
13829            dbg.location(1277,9);
13830            pushFollow(FOLLOW_variableModifiers_in_localVariableHeader7769);
13831            variableModifiers();
13832
13833            state._fsp--;
13834            if (state.failed) return ;
13835            dbg.location(1277,27);
13836            pushFollow(FOLLOW_type_in_localVariableHeader7771);
13837            type();
13838
13839            state._fsp--;
13840            if (state.failed) return ;
13841            dbg.location(1277,32);
13842            match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_localVariableHeader7773); if (state.failed) return ;
13843            dbg.location(1277,43);
13844            // src/com/google/doclava/parser/Java.g:1277:43: ( '[' ']' )*
13845            try { dbg.enterSubRule(165);
13846
13847            loop165:
13848            do {
13849                int alt165=2;
13850                try { dbg.enterDecision(165, decisionCanBacktrack[165]);
13851
13852                int LA165_0 = input.LA(1);
13853
13854                if ( (LA165_0==LBRACKET) ) {
13855                    alt165=1;
13856                }
13857
13858
13859                } finally {dbg.exitDecision(165);}
13860
13861                switch (alt165) {
13862		case 1 :
13863		    dbg.enterAlt(1);
13864
13865		    // src/com/google/doclava/parser/Java.g:1277:44: '[' ']'
13866		    {
13867		    dbg.location(1277,44);
13868		    match(input,LBRACKET,FOLLOW_LBRACKET_in_localVariableHeader7776); if (state.failed) return ;
13869		    dbg.location(1277,47);
13870		    match(input,RBRACKET,FOLLOW_RBRACKET_in_localVariableHeader7777); if (state.failed) return ;
13871
13872		    }
13873		    break;
13874
13875		default :
13876		    break loop165;
13877                }
13878            } while (true);
13879            } finally {dbg.exitSubRule(165);}
13880
13881            dbg.location(1277,53);
13882            if ( (input.LA(1)>=SEMI && input.LA(1)<=COMMA)||input.LA(1)==EQ ) {
13883                input.consume();
13884                state.errorRecovery=false;state.failed=false;
13885            }
13886            else {
13887                if (state.backtracking>0) {state.failed=true; return ;}
13888                MismatchedSetException mse = new MismatchedSetException(null,input);
13889                dbg.recognitionException(mse);
13890                throw mse;
13891            }
13892
13893
13894            }
13895
13896        }
13897        catch (RecognitionException re) {
13898            reportError(re);
13899            recover(input,re);
13900        }
13901        finally {
13902            if ( state.backtracking>0 ) { memoize(input, 110, localVariableHeader_StartIndex); }
13903        }
13904        dbg.location(1278, 5);
13905
13906        }
13907        finally {
13908            dbg.exitRule(getGrammarFileName(), "localVariableHeader");
13909            decRuleLevel();
13910            if ( getRuleLevel()==0 ) {dbg.terminate();}
13911        }
13912
13913        return ;
13914    }
13915    // $ANTLR end "localVariableHeader"
13916
13917    // $ANTLR start synpred2_Java
13918    public final void synpred2_Java_fragment() throws RecognitionException {
13919        // src/com/google/doclava/parser/Java.g:298:13: ( ( annotations )? packageDeclaration )
13920        dbg.enterAlt(1);
13921
13922        // src/com/google/doclava/parser/Java.g:298:13: ( annotations )? packageDeclaration
13923        {
13924        dbg.location(298,13);
13925        // src/com/google/doclava/parser/Java.g:298:13: ( annotations )?
13926        int alt166=2;
13927        try { dbg.enterSubRule(166);
13928        try { dbg.enterDecision(166, decisionCanBacktrack[166]);
13929
13930        int LA166_0 = input.LA(1);
13931
13932        if ( (LA166_0==MONKEYS_AT) ) {
13933            alt166=1;
13934        }
13935        } finally {dbg.exitDecision(166);}
13936
13937        switch (alt166) {
13938            case 1 :
13939                dbg.enterAlt(1);
13940
13941                // src/com/google/doclava/parser/Java.g:298:14: annotations
13942                {
13943                dbg.location(298,14);
13944                pushFollow(FOLLOW_annotations_in_synpred2_Java64);
13945                annotations();
13946
13947                state._fsp--;
13948                if (state.failed) return ;
13949
13950                }
13951                break;
13952
13953        }
13954        } finally {dbg.exitSubRule(166);}
13955
13956        dbg.location(300,13);
13957        pushFollow(FOLLOW_packageDeclaration_in_synpred2_Java93);
13958        packageDeclaration();
13959
13960        state._fsp--;
13961        if (state.failed) return ;
13962
13963        }
13964    }
13965    // $ANTLR end synpred2_Java
13966
13967    // $ANTLR start synpred12_Java
13968    public final void synpred12_Java_fragment() throws RecognitionException {
13969        // src/com/google/doclava/parser/Java.g:342:10: ( classDeclaration )
13970        dbg.enterAlt(1);
13971
13972        // src/com/google/doclava/parser/Java.g:342:10: classDeclaration
13973        {
13974        dbg.location(342,10);
13975        pushFollow(FOLLOW_classDeclaration_in_synpred12_Java436);
13976        classDeclaration();
13977
13978        state._fsp--;
13979        if (state.failed) return ;
13980
13981        }
13982    }
13983    // $ANTLR end synpred12_Java
13984
13985    // $ANTLR start synpred27_Java
13986    public final void synpred27_Java_fragment() throws RecognitionException {
13987        // src/com/google/doclava/parser/Java.g:373:9: ( normalClassDeclaration )
13988        dbg.enterAlt(1);
13989
13990        // src/com/google/doclava/parser/Java.g:373:9: normalClassDeclaration
13991        {
13992        dbg.location(373,9);
13993        pushFollow(FOLLOW_normalClassDeclaration_in_synpred27_Java659);
13994        normalClassDeclaration();
13995
13996        state._fsp--;
13997        if (state.failed) return ;
13998
13999        }
14000    }
14001    // $ANTLR end synpred27_Java
14002
14003    // $ANTLR start synpred43_Java
14004    public final void synpred43_Java_fragment() throws RecognitionException {
14005        // src/com/google/doclava/parser/Java.g:461:9: ( normalInterfaceDeclaration )
14006        dbg.enterAlt(1);
14007
14008        // src/com/google/doclava/parser/Java.g:461:9: normalInterfaceDeclaration
14009        {
14010        dbg.location(461,9);
14011        pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred43_Java1306);
14012        normalInterfaceDeclaration();
14013
14014        state._fsp--;
14015        if (state.failed) return ;
14016
14017        }
14018    }
14019    // $ANTLR end synpred43_Java
14020
14021    // $ANTLR start synpred52_Java
14022    public final void synpred52_Java_fragment() throws RecognitionException {
14023        // src/com/google/doclava/parser/Java.g:503:10: ( fieldDeclaration )
14024        dbg.enterAlt(1);
14025
14026        // src/com/google/doclava/parser/Java.g:503:10: fieldDeclaration
14027        {
14028        dbg.location(503,10);
14029        pushFollow(FOLLOW_fieldDeclaration_in_synpred52_Java1621);
14030        fieldDeclaration();
14031
14032        state._fsp--;
14033        if (state.failed) return ;
14034
14035        }
14036    }
14037    // $ANTLR end synpred52_Java
14038
14039    // $ANTLR start synpred53_Java
14040    public final void synpred53_Java_fragment() throws RecognitionException {
14041        // src/com/google/doclava/parser/Java.g:504:10: ( methodDeclaration )
14042        dbg.enterAlt(1);
14043
14044        // src/com/google/doclava/parser/Java.g:504:10: methodDeclaration
14045        {
14046        dbg.location(504,10);
14047        pushFollow(FOLLOW_methodDeclaration_in_synpred53_Java1632);
14048        methodDeclaration();
14049
14050        state._fsp--;
14051        if (state.failed) return ;
14052
14053        }
14054    }
14055    // $ANTLR end synpred53_Java
14056
14057    // $ANTLR start synpred54_Java
14058    public final void synpred54_Java_fragment() throws RecognitionException {
14059        // src/com/google/doclava/parser/Java.g:505:10: ( classDeclaration )
14060        dbg.enterAlt(1);
14061
14062        // src/com/google/doclava/parser/Java.g:505:10: classDeclaration
14063        {
14064        dbg.location(505,10);
14065        pushFollow(FOLLOW_classDeclaration_in_synpred54_Java1643);
14066        classDeclaration();
14067
14068        state._fsp--;
14069        if (state.failed) return ;
14070
14071        }
14072    }
14073    // $ANTLR end synpred54_Java
14074
14075    // $ANTLR start synpred57_Java
14076    public final void synpred57_Java_fragment() throws RecognitionException {
14077        // src/com/google/doclava/parser/Java.g:521:10: ( explicitConstructorInvocation )
14078        dbg.enterAlt(1);
14079
14080        // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation
14081        {
14082        dbg.location(521,10);
14083        pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred57_Java1778);
14084        explicitConstructorInvocation();
14085
14086        state._fsp--;
14087        if (state.failed) return ;
14088
14089        }
14090    }
14091    // $ANTLR end synpred57_Java
14092
14093    // $ANTLR start synpred59_Java
14094    public final void synpred59_Java_fragment() throws RecognitionException {
14095        // src/com/google/doclava/parser/Java.g:513:10: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' )
14096        dbg.enterAlt(1);
14097
14098        // src/com/google/doclava/parser/Java.g:513:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}'
14099        {
14100        dbg.location(513,10);
14101        pushFollow(FOLLOW_modifiers_in_synpred59_Java1691);
14102        modifiers();
14103
14104        state._fsp--;
14105        if (state.failed) return ;
14106        dbg.location(514,9);
14107        // src/com/google/doclava/parser/Java.g:514:9: ( typeParameters )?
14108        int alt169=2;
14109        try { dbg.enterSubRule(169);
14110        try { dbg.enterDecision(169, decisionCanBacktrack[169]);
14111
14112        int LA169_0 = input.LA(1);
14113
14114        if ( (LA169_0==LT) ) {
14115            alt169=1;
14116        }
14117        } finally {dbg.exitDecision(169);}
14118
14119        switch (alt169) {
14120            case 1 :
14121                dbg.enterAlt(1);
14122
14123                // src/com/google/doclava/parser/Java.g:514:10: typeParameters
14124                {
14125                dbg.location(514,10);
14126                pushFollow(FOLLOW_typeParameters_in_synpred59_Java1702);
14127                typeParameters();
14128
14129                state._fsp--;
14130                if (state.failed) return ;
14131
14132                }
14133                break;
14134
14135        }
14136        } finally {dbg.exitSubRule(169);}
14137
14138        dbg.location(516,9);
14139        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred59_Java1723); if (state.failed) return ;
14140        dbg.location(517,9);
14141        pushFollow(FOLLOW_formalParameters_in_synpred59_Java1733);
14142        formalParameters();
14143
14144        state._fsp--;
14145        if (state.failed) return ;
14146        dbg.location(518,9);
14147        // src/com/google/doclava/parser/Java.g:518:9: ( 'throws' qualifiedNameList )?
14148        int alt170=2;
14149        try { dbg.enterSubRule(170);
14150        try { dbg.enterDecision(170, decisionCanBacktrack[170]);
14151
14152        int LA170_0 = input.LA(1);
14153
14154        if ( (LA170_0==THROWS) ) {
14155            alt170=1;
14156        }
14157        } finally {dbg.exitDecision(170);}
14158
14159        switch (alt170) {
14160            case 1 :
14161                dbg.enterAlt(1);
14162
14163                // src/com/google/doclava/parser/Java.g:518:10: 'throws' qualifiedNameList
14164                {
14165                dbg.location(518,10);
14166                match(input,THROWS,FOLLOW_THROWS_in_synpred59_Java1744); if (state.failed) return ;
14167                dbg.location(518,19);
14168                pushFollow(FOLLOW_qualifiedNameList_in_synpred59_Java1746);
14169                qualifiedNameList();
14170
14171                state._fsp--;
14172                if (state.failed) return ;
14173
14174                }
14175                break;
14176
14177        }
14178        } finally {dbg.exitSubRule(170);}
14179
14180        dbg.location(520,9);
14181        match(input,LBRACE,FOLLOW_LBRACE_in_synpred59_Java1767); if (state.failed) return ;
14182        dbg.location(521,9);
14183        // src/com/google/doclava/parser/Java.g:521:9: ( explicitConstructorInvocation )?
14184        int alt171=2;
14185        try { dbg.enterSubRule(171);
14186        try { dbg.enterDecision(171, decisionCanBacktrack[171]);
14187
14188        try {
14189            isCyclicDecision = true;
14190            alt171 = dfa171.predict(input);
14191        }
14192        catch (NoViableAltException nvae) {
14193            dbg.recognitionException(nvae);
14194            throw nvae;
14195        }
14196        } finally {dbg.exitDecision(171);}
14197
14198        switch (alt171) {
14199            case 1 :
14200                dbg.enterAlt(1);
14201
14202                // src/com/google/doclava/parser/Java.g:521:10: explicitConstructorInvocation
14203                {
14204                dbg.location(521,10);
14205                pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred59_Java1778);
14206                explicitConstructorInvocation();
14207
14208                state._fsp--;
14209                if (state.failed) return ;
14210
14211                }
14212                break;
14213
14214        }
14215        } finally {dbg.exitSubRule(171);}
14216
14217        dbg.location(523,9);
14218        // src/com/google/doclava/parser/Java.g:523:9: ( blockStatement )*
14219        try { dbg.enterSubRule(172);
14220
14221        loop172:
14222        do {
14223            int alt172=2;
14224            try { dbg.enterDecision(172, decisionCanBacktrack[172]);
14225
14226            int LA172_0 = input.LA(1);
14227
14228            if ( ((LA172_0>=IDENTIFIER && LA172_0<=NULL)||(LA172_0>=ABSTRACT && LA172_0<=BYTE)||(LA172_0>=CHAR && LA172_0<=CLASS)||LA172_0==CONTINUE||(LA172_0>=DO && LA172_0<=DOUBLE)||LA172_0==ENUM||LA172_0==FINAL||(LA172_0>=FLOAT && LA172_0<=FOR)||LA172_0==IF||(LA172_0>=INT && LA172_0<=NEW)||(LA172_0>=PRIVATE && LA172_0<=THROW)||(LA172_0>=TRANSIENT && LA172_0<=LPAREN)||LA172_0==LBRACE||LA172_0==SEMI||(LA172_0>=BANG && LA172_0<=TILDE)||(LA172_0>=PLUSPLUS && LA172_0<=SUB)||LA172_0==MONKEYS_AT||LA172_0==LT) ) {
14229                alt172=1;
14230            }
14231
14232
14233            } finally {dbg.exitDecision(172);}
14234
14235            switch (alt172) {
14236		case 1 :
14237		    dbg.enterAlt(1);
14238
14239		    // src/com/google/doclava/parser/Java.g:523:10: blockStatement
14240		    {
14241		    dbg.location(523,10);
14242		    pushFollow(FOLLOW_blockStatement_in_synpred59_Java1800);
14243		    blockStatement();
14244
14245		    state._fsp--;
14246		    if (state.failed) return ;
14247
14248		    }
14249		    break;
14250
14251		default :
14252		    break loop172;
14253            }
14254        } while (true);
14255        } finally {dbg.exitSubRule(172);}
14256
14257        dbg.location(525,9);
14258        match(input,RBRACE,FOLLOW_RBRACE_in_synpred59_Java1821); if (state.failed) return ;
14259
14260        }
14261    }
14262    // $ANTLR end synpred59_Java
14263
14264    // $ANTLR start synpred68_Java
14265    public final void synpred68_Java_fragment() throws RecognitionException {
14266        // src/com/google/doclava/parser/Java.g:567:9: ( interfaceFieldDeclaration )
14267        dbg.enterAlt(1);
14268
14269        // src/com/google/doclava/parser/Java.g:567:9: interfaceFieldDeclaration
14270        {
14271        dbg.location(567,9);
14272        pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred68_Java2172);
14273        interfaceFieldDeclaration();
14274
14275        state._fsp--;
14276        if (state.failed) return ;
14277
14278        }
14279    }
14280    // $ANTLR end synpred68_Java
14281
14282    // $ANTLR start synpred69_Java
14283    public final void synpred69_Java_fragment() throws RecognitionException {
14284        // src/com/google/doclava/parser/Java.g:568:9: ( interfaceMethodDeclaration )
14285        dbg.enterAlt(1);
14286
14287        // src/com/google/doclava/parser/Java.g:568:9: interfaceMethodDeclaration
14288        {
14289        dbg.location(568,9);
14290        pushFollow(FOLLOW_interfaceMethodDeclaration_in_synpred69_Java2182);
14291        interfaceMethodDeclaration();
14292
14293        state._fsp--;
14294        if (state.failed) return ;
14295
14296        }
14297    }
14298    // $ANTLR end synpred69_Java
14299
14300    // $ANTLR start synpred70_Java
14301    public final void synpred70_Java_fragment() throws RecognitionException {
14302        // src/com/google/doclava/parser/Java.g:569:9: ( interfaceDeclaration )
14303        dbg.enterAlt(1);
14304
14305        // src/com/google/doclava/parser/Java.g:569:9: interfaceDeclaration
14306        {
14307        dbg.location(569,9);
14308        pushFollow(FOLLOW_interfaceDeclaration_in_synpred70_Java2192);
14309        interfaceDeclaration();
14310
14311        state._fsp--;
14312        if (state.failed) return ;
14313
14314        }
14315    }
14316    // $ANTLR end synpred70_Java
14317
14318    // $ANTLR start synpred71_Java
14319    public final void synpred71_Java_fragment() throws RecognitionException {
14320        // src/com/google/doclava/parser/Java.g:570:9: ( classDeclaration )
14321        dbg.enterAlt(1);
14322
14323        // src/com/google/doclava/parser/Java.g:570:9: classDeclaration
14324        {
14325        dbg.location(570,9);
14326        pushFollow(FOLLOW_classDeclaration_in_synpred71_Java2202);
14327        classDeclaration();
14328
14329        state._fsp--;
14330        if (state.failed) return ;
14331
14332        }
14333    }
14334    // $ANTLR end synpred71_Java
14335
14336    // $ANTLR start synpred96_Java
14337    public final void synpred96_Java_fragment() throws RecognitionException {
14338        // src/com/google/doclava/parser/Java.g:665:9: ( ellipsisParameterDecl )
14339        dbg.enterAlt(1);
14340
14341        // src/com/google/doclava/parser/Java.g:665:9: ellipsisParameterDecl
14342        {
14343        dbg.location(665,9);
14344        pushFollow(FOLLOW_ellipsisParameterDecl_in_synpred96_Java2953);
14345        ellipsisParameterDecl();
14346
14347        state._fsp--;
14348        if (state.failed) return ;
14349
14350        }
14351    }
14352    // $ANTLR end synpred96_Java
14353
14354    // $ANTLR start synpred98_Java
14355    public final void synpred98_Java_fragment() throws RecognitionException {
14356        // src/com/google/doclava/parser/Java.g:666:9: ( normalParameterDecl ( ',' normalParameterDecl )* )
14357        dbg.enterAlt(1);
14358
14359        // src/com/google/doclava/parser/Java.g:666:9: normalParameterDecl ( ',' normalParameterDecl )*
14360        {
14361        dbg.location(666,9);
14362        pushFollow(FOLLOW_normalParameterDecl_in_synpred98_Java2963);
14363        normalParameterDecl();
14364
14365        state._fsp--;
14366        if (state.failed) return ;
14367        dbg.location(667,9);
14368        // src/com/google/doclava/parser/Java.g:667:9: ( ',' normalParameterDecl )*
14369        try { dbg.enterSubRule(175);
14370
14371        loop175:
14372        do {
14373            int alt175=2;
14374            try { dbg.enterDecision(175, decisionCanBacktrack[175]);
14375
14376            int LA175_0 = input.LA(1);
14377
14378            if ( (LA175_0==COMMA) ) {
14379                alt175=1;
14380            }
14381
14382
14383            } finally {dbg.exitDecision(175);}
14384
14385            switch (alt175) {
14386		case 1 :
14387		    dbg.enterAlt(1);
14388
14389		    // src/com/google/doclava/parser/Java.g:667:10: ',' normalParameterDecl
14390		    {
14391		    dbg.location(667,10);
14392		    match(input,COMMA,FOLLOW_COMMA_in_synpred98_Java2974); if (state.failed) return ;
14393		    dbg.location(667,14);
14394		    pushFollow(FOLLOW_normalParameterDecl_in_synpred98_Java2976);
14395		    normalParameterDecl();
14396
14397		    state._fsp--;
14398		    if (state.failed) return ;
14399
14400		    }
14401		    break;
14402
14403		default :
14404		    break loop175;
14405            }
14406        } while (true);
14407        } finally {dbg.exitSubRule(175);}
14408
14409
14410        }
14411    }
14412    // $ANTLR end synpred98_Java
14413
14414    // $ANTLR start synpred99_Java
14415    public final void synpred99_Java_fragment() throws RecognitionException {
14416        // src/com/google/doclava/parser/Java.g:669:10: ( normalParameterDecl ',' )
14417        dbg.enterAlt(1);
14418
14419        // src/com/google/doclava/parser/Java.g:669:10: normalParameterDecl ','
14420        {
14421        dbg.location(669,10);
14422        pushFollow(FOLLOW_normalParameterDecl_in_synpred99_Java2998);
14423        normalParameterDecl();
14424
14425        state._fsp--;
14426        if (state.failed) return ;
14427        dbg.location(670,9);
14428        match(input,COMMA,FOLLOW_COMMA_in_synpred99_Java3008); if (state.failed) return ;
14429
14430        }
14431    }
14432    // $ANTLR end synpred99_Java
14433
14434    // $ANTLR start synpred103_Java
14435    public final void synpred103_Java_fragment() throws RecognitionException {
14436        // src/com/google/doclava/parser/Java.g:689:9: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' )
14437        dbg.enterAlt(1);
14438
14439        // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';'
14440        {
14441        dbg.location(689,9);
14442        // src/com/google/doclava/parser/Java.g:689:9: ( nonWildcardTypeArguments )?
14443        int alt176=2;
14444        try { dbg.enterSubRule(176);
14445        try { dbg.enterDecision(176, decisionCanBacktrack[176]);
14446
14447        int LA176_0 = input.LA(1);
14448
14449        if ( (LA176_0==LT) ) {
14450            alt176=1;
14451        }
14452        } finally {dbg.exitDecision(176);}
14453
14454        switch (alt176) {
14455            case 1 :
14456                dbg.enterAlt(1);
14457
14458                // src/com/google/doclava/parser/Java.g:689:10: nonWildcardTypeArguments
14459                {
14460                dbg.location(689,10);
14461                pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred103_Java3139);
14462                nonWildcardTypeArguments();
14463
14464                state._fsp--;
14465                if (state.failed) return ;
14466
14467                }
14468                break;
14469
14470        }
14471        } finally {dbg.exitSubRule(176);}
14472
14473        dbg.location(691,9);
14474        if ( input.LA(1)==SUPER||input.LA(1)==THIS ) {
14475            input.consume();
14476            state.errorRecovery=false;state.failed=false;
14477        }
14478        else {
14479            if (state.backtracking>0) {state.failed=true; return ;}
14480            MismatchedSetException mse = new MismatchedSetException(null,input);
14481            dbg.recognitionException(mse);
14482            throw mse;
14483        }
14484
14485        dbg.location(694,9);
14486        pushFollow(FOLLOW_arguments_in_synpred103_Java3197);
14487        arguments();
14488
14489        state._fsp--;
14490        if (state.failed) return ;
14491        dbg.location(694,19);
14492        match(input,SEMI,FOLLOW_SEMI_in_synpred103_Java3199); if (state.failed) return ;
14493
14494        }
14495    }
14496    // $ANTLR end synpred103_Java
14497
14498    // $ANTLR start synpred117_Java
14499    public final void synpred117_Java_fragment() throws RecognitionException {
14500        // src/com/google/doclava/parser/Java.g:776:9: ( annotationMethodDeclaration )
14501        dbg.enterAlt(1);
14502
14503        // src/com/google/doclava/parser/Java.g:776:9: annotationMethodDeclaration
14504        {
14505        dbg.location(776,9);
14506        pushFollow(FOLLOW_annotationMethodDeclaration_in_synpred117_Java3781);
14507        annotationMethodDeclaration();
14508
14509        state._fsp--;
14510        if (state.failed) return ;
14511
14512        }
14513    }
14514    // $ANTLR end synpred117_Java
14515
14516    // $ANTLR start synpred118_Java
14517    public final void synpred118_Java_fragment() throws RecognitionException {
14518        // src/com/google/doclava/parser/Java.g:777:9: ( interfaceFieldDeclaration )
14519        dbg.enterAlt(1);
14520
14521        // src/com/google/doclava/parser/Java.g:777:9: interfaceFieldDeclaration
14522        {
14523        dbg.location(777,9);
14524        pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred118_Java3791);
14525        interfaceFieldDeclaration();
14526
14527        state._fsp--;
14528        if (state.failed) return ;
14529
14530        }
14531    }
14532    // $ANTLR end synpred118_Java
14533
14534    // $ANTLR start synpred119_Java
14535    public final void synpred119_Java_fragment() throws RecognitionException {
14536        // src/com/google/doclava/parser/Java.g:778:9: ( normalClassDeclaration )
14537        dbg.enterAlt(1);
14538
14539        // src/com/google/doclava/parser/Java.g:778:9: normalClassDeclaration
14540        {
14541        dbg.location(778,9);
14542        pushFollow(FOLLOW_normalClassDeclaration_in_synpred119_Java3801);
14543        normalClassDeclaration();
14544
14545        state._fsp--;
14546        if (state.failed) return ;
14547
14548        }
14549    }
14550    // $ANTLR end synpred119_Java
14551
14552    // $ANTLR start synpred120_Java
14553    public final void synpred120_Java_fragment() throws RecognitionException {
14554        // src/com/google/doclava/parser/Java.g:779:9: ( normalInterfaceDeclaration )
14555        dbg.enterAlt(1);
14556
14557        // src/com/google/doclava/parser/Java.g:779:9: normalInterfaceDeclaration
14558        {
14559        dbg.location(779,9);
14560        pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred120_Java3811);
14561        normalInterfaceDeclaration();
14562
14563        state._fsp--;
14564        if (state.failed) return ;
14565
14566        }
14567    }
14568    // $ANTLR end synpred120_Java
14569
14570    // $ANTLR start synpred121_Java
14571    public final void synpred121_Java_fragment() throws RecognitionException {
14572        // src/com/google/doclava/parser/Java.g:780:9: ( enumDeclaration )
14573        dbg.enterAlt(1);
14574
14575        // src/com/google/doclava/parser/Java.g:780:9: enumDeclaration
14576        {
14577        dbg.location(780,9);
14578        pushFollow(FOLLOW_enumDeclaration_in_synpred121_Java3821);
14579        enumDeclaration();
14580
14581        state._fsp--;
14582        if (state.failed) return ;
14583
14584        }
14585    }
14586    // $ANTLR end synpred121_Java
14587
14588    // $ANTLR start synpred122_Java
14589    public final void synpred122_Java_fragment() throws RecognitionException {
14590        // src/com/google/doclava/parser/Java.g:781:9: ( annotationTypeDeclaration )
14591        dbg.enterAlt(1);
14592
14593        // src/com/google/doclava/parser/Java.g:781:9: annotationTypeDeclaration
14594        {
14595        dbg.location(781,9);
14596        pushFollow(FOLLOW_annotationTypeDeclaration_in_synpred122_Java3831);
14597        annotationTypeDeclaration();
14598
14599        state._fsp--;
14600        if (state.failed) return ;
14601
14602        }
14603    }
14604    // $ANTLR end synpred122_Java
14605
14606    // $ANTLR start synpred125_Java
14607    public final void synpred125_Java_fragment() throws RecognitionException {
14608        // src/com/google/doclava/parser/Java.g:824:9: ( localVariableDeclarationStatement )
14609        dbg.enterAlt(1);
14610
14611        // src/com/google/doclava/parser/Java.g:824:9: localVariableDeclarationStatement
14612        {
14613        dbg.location(824,9);
14614        pushFollow(FOLLOW_localVariableDeclarationStatement_in_synpred125_Java3986);
14615        localVariableDeclarationStatement();
14616
14617        state._fsp--;
14618        if (state.failed) return ;
14619
14620        }
14621    }
14622    // $ANTLR end synpred125_Java
14623
14624    // $ANTLR start synpred126_Java
14625    public final void synpred126_Java_fragment() throws RecognitionException {
14626        // src/com/google/doclava/parser/Java.g:825:9: ( classOrInterfaceDeclaration )
14627        dbg.enterAlt(1);
14628
14629        // src/com/google/doclava/parser/Java.g:825:9: classOrInterfaceDeclaration
14630        {
14631        dbg.location(825,9);
14632        pushFollow(FOLLOW_classOrInterfaceDeclaration_in_synpred126_Java3996);
14633        classOrInterfaceDeclaration();
14634
14635        state._fsp--;
14636        if (state.failed) return ;
14637
14638        }
14639    }
14640    // $ANTLR end synpred126_Java
14641
14642    // $ANTLR start synpred130_Java
14643    public final void synpred130_Java_fragment() throws RecognitionException {
14644        // src/com/google/doclava/parser/Java.g:845:9: ( ( 'assert' ) expression ( ':' expression )? ';' )
14645        dbg.enterAlt(1);
14646
14647        // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' ) expression ( ':' expression )? ';'
14648        {
14649        dbg.location(845,9);
14650        // src/com/google/doclava/parser/Java.g:845:9: ( 'assert' )
14651        dbg.enterAlt(1);
14652
14653        // src/com/google/doclava/parser/Java.g:845:10: 'assert'
14654        {
14655        dbg.location(845,10);
14656        match(input,ASSERT,FOLLOW_ASSERT_in_synpred130_Java4122); if (state.failed) return ;
14657
14658        }
14659
14660        dbg.location(847,9);
14661        pushFollow(FOLLOW_expression_in_synpred130_Java4142);
14662        expression();
14663
14664        state._fsp--;
14665        if (state.failed) return ;
14666        dbg.location(847,20);
14667        // src/com/google/doclava/parser/Java.g:847:20: ( ':' expression )?
14668        int alt179=2;
14669        try { dbg.enterSubRule(179);
14670        try { dbg.enterDecision(179, decisionCanBacktrack[179]);
14671
14672        int LA179_0 = input.LA(1);
14673
14674        if ( (LA179_0==COLON) ) {
14675            alt179=1;
14676        }
14677        } finally {dbg.exitDecision(179);}
14678
14679        switch (alt179) {
14680            case 1 :
14681                dbg.enterAlt(1);
14682
14683                // src/com/google/doclava/parser/Java.g:847:21: ':' expression
14684                {
14685                dbg.location(847,21);
14686                match(input,COLON,FOLLOW_COLON_in_synpred130_Java4145); if (state.failed) return ;
14687                dbg.location(847,25);
14688                pushFollow(FOLLOW_expression_in_synpred130_Java4147);
14689                expression();
14690
14691                state._fsp--;
14692                if (state.failed) return ;
14693
14694                }
14695                break;
14696
14697        }
14698        } finally {dbg.exitSubRule(179);}
14699
14700        dbg.location(847,38);
14701        match(input,SEMI,FOLLOW_SEMI_in_synpred130_Java4151); if (state.failed) return ;
14702
14703        }
14704    }
14705    // $ANTLR end synpred130_Java
14706
14707    // $ANTLR start synpred132_Java
14708    public final void synpred132_Java_fragment() throws RecognitionException {
14709        // src/com/google/doclava/parser/Java.g:848:9: ( 'assert' expression ( ':' expression )? ';' )
14710        dbg.enterAlt(1);
14711
14712        // src/com/google/doclava/parser/Java.g:848:9: 'assert' expression ( ':' expression )? ';'
14713        {
14714        dbg.location(848,9);
14715        match(input,ASSERT,FOLLOW_ASSERT_in_synpred132_Java4161); if (state.failed) return ;
14716        dbg.location(848,19);
14717        pushFollow(FOLLOW_expression_in_synpred132_Java4164);
14718        expression();
14719
14720        state._fsp--;
14721        if (state.failed) return ;
14722        dbg.location(848,30);
14723        // src/com/google/doclava/parser/Java.g:848:30: ( ':' expression )?
14724        int alt180=2;
14725        try { dbg.enterSubRule(180);
14726        try { dbg.enterDecision(180, decisionCanBacktrack[180]);
14727
14728        int LA180_0 = input.LA(1);
14729
14730        if ( (LA180_0==COLON) ) {
14731            alt180=1;
14732        }
14733        } finally {dbg.exitDecision(180);}
14734
14735        switch (alt180) {
14736            case 1 :
14737                dbg.enterAlt(1);
14738
14739                // src/com/google/doclava/parser/Java.g:848:31: ':' expression
14740                {
14741                dbg.location(848,31);
14742                match(input,COLON,FOLLOW_COLON_in_synpred132_Java4167); if (state.failed) return ;
14743                dbg.location(848,35);
14744                pushFollow(FOLLOW_expression_in_synpred132_Java4169);
14745                expression();
14746
14747                state._fsp--;
14748                if (state.failed) return ;
14749
14750                }
14751                break;
14752
14753        }
14754        } finally {dbg.exitSubRule(180);}
14755
14756        dbg.location(848,48);
14757        match(input,SEMI,FOLLOW_SEMI_in_synpred132_Java4173); if (state.failed) return ;
14758
14759        }
14760    }
14761    // $ANTLR end synpred132_Java
14762
14763    // $ANTLR start synpred133_Java
14764    public final void synpred133_Java_fragment() throws RecognitionException {
14765        // src/com/google/doclava/parser/Java.g:849:39: ( 'else' statement )
14766        dbg.enterAlt(1);
14767
14768        // src/com/google/doclava/parser/Java.g:849:39: 'else' statement
14769        {
14770        dbg.location(849,39);
14771        match(input,ELSE,FOLLOW_ELSE_in_synpred133_Java4190); if (state.failed) return ;
14772        dbg.location(849,46);
14773        pushFollow(FOLLOW_statement_in_synpred133_Java4192);
14774        statement();
14775
14776        state._fsp--;
14777        if (state.failed) return ;
14778
14779        }
14780    }
14781    // $ANTLR end synpred133_Java
14782
14783    // $ANTLR start synpred148_Java
14784    public final void synpred148_Java_fragment() throws RecognitionException {
14785        // src/com/google/doclava/parser/Java.g:864:9: ( expression ';' )
14786        dbg.enterAlt(1);
14787
14788        // src/com/google/doclava/parser/Java.g:864:9: expression ';'
14789        {
14790        dbg.location(864,9);
14791        pushFollow(FOLLOW_expression_in_synpred148_Java4404);
14792        expression();
14793
14794        state._fsp--;
14795        if (state.failed) return ;
14796        dbg.location(864,21);
14797        match(input,SEMI,FOLLOW_SEMI_in_synpred148_Java4407); if (state.failed) return ;
14798
14799        }
14800    }
14801    // $ANTLR end synpred148_Java
14802
14803    // $ANTLR start synpred149_Java
14804    public final void synpred149_Java_fragment() throws RecognitionException {
14805        // src/com/google/doclava/parser/Java.g:865:9: ( IDENTIFIER ':' statement )
14806        dbg.enterAlt(1);
14807
14808        // src/com/google/doclava/parser/Java.g:865:9: IDENTIFIER ':' statement
14809        {
14810        dbg.location(865,9);
14811        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred149_Java4417); if (state.failed) return ;
14812        dbg.location(865,20);
14813        match(input,COLON,FOLLOW_COLON_in_synpred149_Java4419); if (state.failed) return ;
14814        dbg.location(865,24);
14815        pushFollow(FOLLOW_statement_in_synpred149_Java4421);
14816        statement();
14817
14818        state._fsp--;
14819        if (state.failed) return ;
14820
14821        }
14822    }
14823    // $ANTLR end synpred149_Java
14824
14825    // $ANTLR start synpred153_Java
14826    public final void synpred153_Java_fragment() throws RecognitionException {
14827        // src/com/google/doclava/parser/Java.g:889:13: ( catches 'finally' block )
14828        dbg.enterAlt(1);
14829
14830        // src/com/google/doclava/parser/Java.g:889:13: catches 'finally' block
14831        {
14832        dbg.location(889,13);
14833        pushFollow(FOLLOW_catches_in_synpred153_Java4573);
14834        catches();
14835
14836        state._fsp--;
14837        if (state.failed) return ;
14838        dbg.location(889,21);
14839        match(input,FINALLY,FOLLOW_FINALLY_in_synpred153_Java4575); if (state.failed) return ;
14840        dbg.location(889,31);
14841        pushFollow(FOLLOW_block_in_synpred153_Java4577);
14842        block();
14843
14844        state._fsp--;
14845        if (state.failed) return ;
14846
14847        }
14848    }
14849    // $ANTLR end synpred153_Java
14850
14851    // $ANTLR start synpred154_Java
14852    public final void synpred154_Java_fragment() throws RecognitionException {
14853        // src/com/google/doclava/parser/Java.g:890:13: ( catches )
14854        dbg.enterAlt(1);
14855
14856        // src/com/google/doclava/parser/Java.g:890:13: catches
14857        {
14858        dbg.location(890,13);
14859        pushFollow(FOLLOW_catches_in_synpred154_Java4591);
14860        catches();
14861
14862        state._fsp--;
14863        if (state.failed) return ;
14864
14865        }
14866    }
14867    // $ANTLR end synpred154_Java
14868
14869    // $ANTLR start synpred157_Java
14870    public final void synpred157_Java_fragment() throws RecognitionException {
14871        // src/com/google/doclava/parser/Java.g:915:9: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement )
14872        dbg.enterAlt(1);
14873
14874        // src/com/google/doclava/parser/Java.g:915:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement
14875        {
14876        dbg.location(915,9);
14877        match(input,FOR,FOLLOW_FOR_in_synpred157_Java4775); if (state.failed) return ;
14878        dbg.location(915,15);
14879        match(input,LPAREN,FOLLOW_LPAREN_in_synpred157_Java4777); if (state.failed) return ;
14880        dbg.location(915,19);
14881        pushFollow(FOLLOW_variableModifiers_in_synpred157_Java4779);
14882        variableModifiers();
14883
14884        state._fsp--;
14885        if (state.failed) return ;
14886        dbg.location(915,37);
14887        pushFollow(FOLLOW_type_in_synpred157_Java4781);
14888        type();
14889
14890        state._fsp--;
14891        if (state.failed) return ;
14892        dbg.location(915,42);
14893        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred157_Java4783); if (state.failed) return ;
14894        dbg.location(915,53);
14895        match(input,COLON,FOLLOW_COLON_in_synpred157_Java4785); if (state.failed) return ;
14896        dbg.location(916,9);
14897        pushFollow(FOLLOW_expression_in_synpred157_Java4795);
14898        expression();
14899
14900        state._fsp--;
14901        if (state.failed) return ;
14902        dbg.location(916,20);
14903        match(input,RPAREN,FOLLOW_RPAREN_in_synpred157_Java4797); if (state.failed) return ;
14904        dbg.location(916,24);
14905        pushFollow(FOLLOW_statement_in_synpred157_Java4799);
14906        statement();
14907
14908        state._fsp--;
14909        if (state.failed) return ;
14910
14911        }
14912    }
14913    // $ANTLR end synpred157_Java
14914
14915    // $ANTLR start synpred161_Java
14916    public final void synpred161_Java_fragment() throws RecognitionException {
14917        // src/com/google/doclava/parser/Java.g:929:9: ( localVariableDeclaration )
14918        dbg.enterAlt(1);
14919
14920        // src/com/google/doclava/parser/Java.g:929:9: localVariableDeclaration
14921        {
14922        dbg.location(929,9);
14923        pushFollow(FOLLOW_localVariableDeclaration_in_synpred161_Java4962);
14924        localVariableDeclaration();
14925
14926        state._fsp--;
14927        if (state.failed) return ;
14928
14929        }
14930    }
14931    // $ANTLR end synpred161_Java
14932
14933    // $ANTLR start synpred202_Java
14934    public final void synpred202_Java_fragment() throws RecognitionException {
14935        // src/com/google/doclava/parser/Java.g:1083:9: ( castExpression )
14936        dbg.enterAlt(1);
14937
14938        // src/com/google/doclava/parser/Java.g:1083:9: castExpression
14939        {
14940        dbg.location(1083,9);
14941        pushFollow(FOLLOW_castExpression_in_synpred202_Java6178);
14942        castExpression();
14943
14944        state._fsp--;
14945        if (state.failed) return ;
14946
14947        }
14948    }
14949    // $ANTLR end synpred202_Java
14950
14951    // $ANTLR start synpred206_Java
14952    public final void synpred206_Java_fragment() throws RecognitionException {
14953        // src/com/google/doclava/parser/Java.g:1093:9: ( '(' primitiveType ')' unaryExpression )
14954        dbg.enterAlt(1);
14955
14956        // src/com/google/doclava/parser/Java.g:1093:9: '(' primitiveType ')' unaryExpression
14957        {
14958        dbg.location(1093,9);
14959        match(input,LPAREN,FOLLOW_LPAREN_in_synpred206_Java6268); if (state.failed) return ;
14960        dbg.location(1093,13);
14961        pushFollow(FOLLOW_primitiveType_in_synpred206_Java6270);
14962        primitiveType();
14963
14964        state._fsp--;
14965        if (state.failed) return ;
14966        dbg.location(1093,27);
14967        match(input,RPAREN,FOLLOW_RPAREN_in_synpred206_Java6272); if (state.failed) return ;
14968        dbg.location(1093,31);
14969        pushFollow(FOLLOW_unaryExpression_in_synpred206_Java6274);
14970        unaryExpression();
14971
14972        state._fsp--;
14973        if (state.failed) return ;
14974
14975        }
14976    }
14977    // $ANTLR end synpred206_Java
14978
14979    // $ANTLR start synpred208_Java
14980    public final void synpred208_Java_fragment() throws RecognitionException {
14981        // src/com/google/doclava/parser/Java.g:1103:10: ( '.' IDENTIFIER )
14982        dbg.enterAlt(1);
14983
14984        // src/com/google/doclava/parser/Java.g:1103:10: '.' IDENTIFIER
14985        {
14986        dbg.location(1103,10);
14987        match(input,DOT,FOLLOW_DOT_in_synpred208_Java6332); if (state.failed) return ;
14988        dbg.location(1103,14);
14989        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred208_Java6334); if (state.failed) return ;
14990
14991        }
14992    }
14993    // $ANTLR end synpred208_Java
14994
14995    // $ANTLR start synpred209_Java
14996    public final void synpred209_Java_fragment() throws RecognitionException {
14997        // src/com/google/doclava/parser/Java.g:1105:10: ( identifierSuffix )
14998        dbg.enterAlt(1);
14999
15000        // src/com/google/doclava/parser/Java.g:1105:10: identifierSuffix
15001        {
15002        dbg.location(1105,10);
15003        pushFollow(FOLLOW_identifierSuffix_in_synpred209_Java6356);
15004        identifierSuffix();
15005
15006        state._fsp--;
15007        if (state.failed) return ;
15008
15009        }
15010    }
15011    // $ANTLR end synpred209_Java
15012
15013    // $ANTLR start synpred211_Java
15014    public final void synpred211_Java_fragment() throws RecognitionException {
15015        // src/com/google/doclava/parser/Java.g:1108:10: ( '.' IDENTIFIER )
15016        dbg.enterAlt(1);
15017
15018        // src/com/google/doclava/parser/Java.g:1108:10: '.' IDENTIFIER
15019        {
15020        dbg.location(1108,10);
15021        match(input,DOT,FOLLOW_DOT_in_synpred211_Java6388); if (state.failed) return ;
15022        dbg.location(1108,14);
15023        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred211_Java6390); if (state.failed) return ;
15024
15025        }
15026    }
15027    // $ANTLR end synpred211_Java
15028
15029    // $ANTLR start synpred212_Java
15030    public final void synpred212_Java_fragment() throws RecognitionException {
15031        // src/com/google/doclava/parser/Java.g:1110:10: ( identifierSuffix )
15032        dbg.enterAlt(1);
15033
15034        // src/com/google/doclava/parser/Java.g:1110:10: identifierSuffix
15035        {
15036        dbg.location(1110,10);
15037        pushFollow(FOLLOW_identifierSuffix_in_synpred212_Java6412);
15038        identifierSuffix();
15039
15040        state._fsp--;
15041        if (state.failed) return ;
15042
15043        }
15044    }
15045    // $ANTLR end synpred212_Java
15046
15047    // $ANTLR start synpred224_Java
15048    public final void synpred224_Java_fragment() throws RecognitionException {
15049        // src/com/google/doclava/parser/Java.g:1138:10: ( '[' expression ']' )
15050        dbg.enterAlt(1);
15051
15052        // src/com/google/doclava/parser/Java.g:1138:10: '[' expression ']'
15053        {
15054        dbg.location(1138,10);
15055        match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred224_Java6656); if (state.failed) return ;
15056        dbg.location(1138,14);
15057        pushFollow(FOLLOW_expression_in_synpred224_Java6658);
15058        expression();
15059
15060        state._fsp--;
15061        if (state.failed) return ;
15062        dbg.location(1138,25);
15063        match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred224_Java6660); if (state.failed) return ;
15064
15065        }
15066    }
15067    // $ANTLR end synpred224_Java
15068
15069    // $ANTLR start synpred236_Java
15070    public final void synpred236_Java_fragment() throws RecognitionException {
15071        // src/com/google/doclava/parser/Java.g:1161:9: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest )
15072        dbg.enterAlt(1);
15073
15074        // src/com/google/doclava/parser/Java.g:1161:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest
15075        {
15076        dbg.location(1161,9);
15077        match(input,NEW,FOLLOW_NEW_in_synpred236_Java6866); if (state.failed) return ;
15078        dbg.location(1161,15);
15079        pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred236_Java6868);
15080        nonWildcardTypeArguments();
15081
15082        state._fsp--;
15083        if (state.failed) return ;
15084        dbg.location(1161,40);
15085        pushFollow(FOLLOW_classOrInterfaceType_in_synpred236_Java6870);
15086        classOrInterfaceType();
15087
15088        state._fsp--;
15089        if (state.failed) return ;
15090        dbg.location(1161,61);
15091        pushFollow(FOLLOW_classCreatorRest_in_synpred236_Java6872);
15092        classCreatorRest();
15093
15094        state._fsp--;
15095        if (state.failed) return ;
15096
15097        }
15098    }
15099    // $ANTLR end synpred236_Java
15100
15101    // $ANTLR start synpred237_Java
15102    public final void synpred237_Java_fragment() throws RecognitionException {
15103        // src/com/google/doclava/parser/Java.g:1162:9: ( 'new' classOrInterfaceType classCreatorRest )
15104        dbg.enterAlt(1);
15105
15106        // src/com/google/doclava/parser/Java.g:1162:9: 'new' classOrInterfaceType classCreatorRest
15107        {
15108        dbg.location(1162,9);
15109        match(input,NEW,FOLLOW_NEW_in_synpred237_Java6882); if (state.failed) return ;
15110        dbg.location(1162,15);
15111        pushFollow(FOLLOW_classOrInterfaceType_in_synpred237_Java6884);
15112        classOrInterfaceType();
15113
15114        state._fsp--;
15115        if (state.failed) return ;
15116        dbg.location(1162,36);
15117        pushFollow(FOLLOW_classCreatorRest_in_synpred237_Java6886);
15118        classCreatorRest();
15119
15120        state._fsp--;
15121        if (state.failed) return ;
15122
15123        }
15124    }
15125    // $ANTLR end synpred237_Java
15126
15127    // $ANTLR start synpred239_Java
15128    public final void synpred239_Java_fragment() throws RecognitionException {
15129        // src/com/google/doclava/parser/Java.g:1167:9: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer )
15130        dbg.enterAlt(1);
15131
15132        // src/com/google/doclava/parser/Java.g:1167:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer
15133        {
15134        dbg.location(1167,9);
15135        match(input,NEW,FOLLOW_NEW_in_synpred239_Java6915); if (state.failed) return ;
15136        dbg.location(1167,15);
15137        pushFollow(FOLLOW_createdName_in_synpred239_Java6917);
15138        createdName();
15139
15140        state._fsp--;
15141        if (state.failed) return ;
15142        dbg.location(1168,9);
15143        match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred239_Java6927); if (state.failed) return ;
15144        dbg.location(1168,13);
15145        match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred239_Java6929); if (state.failed) return ;
15146        dbg.location(1169,9);
15147        // src/com/google/doclava/parser/Java.g:1169:9: ( '[' ']' )*
15148        try { dbg.enterSubRule(193);
15149
15150        loop193:
15151        do {
15152            int alt193=2;
15153            try { dbg.enterDecision(193, decisionCanBacktrack[193]);
15154
15155            int LA193_0 = input.LA(1);
15156
15157            if ( (LA193_0==LBRACKET) ) {
15158                alt193=1;
15159            }
15160
15161
15162            } finally {dbg.exitDecision(193);}
15163
15164            switch (alt193) {
15165		case 1 :
15166		    dbg.enterAlt(1);
15167
15168		    // src/com/google/doclava/parser/Java.g:1169:10: '[' ']'
15169		    {
15170		    dbg.location(1169,10);
15171		    match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred239_Java6940); if (state.failed) return ;
15172		    dbg.location(1169,14);
15173		    match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred239_Java6942); if (state.failed) return ;
15174
15175		    }
15176		    break;
15177
15178		default :
15179		    break loop193;
15180            }
15181        } while (true);
15182        } finally {dbg.exitSubRule(193);}
15183
15184        dbg.location(1171,9);
15185        pushFollow(FOLLOW_arrayInitializer_in_synpred239_Java6963);
15186        arrayInitializer();
15187
15188        state._fsp--;
15189        if (state.failed) return ;
15190
15191        }
15192    }
15193    // $ANTLR end synpred239_Java
15194
15195    // $ANTLR start synpred240_Java
15196    public final void synpred240_Java_fragment() throws RecognitionException {
15197        // src/com/google/doclava/parser/Java.g:1176:13: ( '[' expression ']' )
15198        dbg.enterAlt(1);
15199
15200        // src/com/google/doclava/parser/Java.g:1176:13: '[' expression ']'
15201        {
15202        dbg.location(1176,13);
15203        match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred240_Java7012); if (state.failed) return ;
15204        dbg.location(1176,17);
15205        pushFollow(FOLLOW_expression_in_synpred240_Java7014);
15206        expression();
15207
15208        state._fsp--;
15209        if (state.failed) return ;
15210        dbg.location(1177,13);
15211        match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred240_Java7028); if (state.failed) return ;
15212
15213        }
15214    }
15215    // $ANTLR end synpred240_Java
15216
15217    // Delegated rules
15218
15219    public final boolean synpred43_Java() {
15220        state.backtracking++;
15221        dbg.beginBacktrack(state.backtracking);
15222        int start = input.mark();
15223        try {
15224            synpred43_Java_fragment(); // can never throw exception
15225        } catch (RecognitionException re) {
15226            System.err.println("impossible: "+re);
15227        }
15228        boolean success = !state.failed;
15229        input.rewind(start);
15230        dbg.endBacktrack(state.backtracking, success);
15231        state.backtracking--;
15232        state.failed=false;
15233        return success;
15234    }
15235    public final boolean synpred98_Java() {
15236        state.backtracking++;
15237        dbg.beginBacktrack(state.backtracking);
15238        int start = input.mark();
15239        try {
15240            synpred98_Java_fragment(); // can never throw exception
15241        } catch (RecognitionException re) {
15242            System.err.println("impossible: "+re);
15243        }
15244        boolean success = !state.failed;
15245        input.rewind(start);
15246        dbg.endBacktrack(state.backtracking, success);
15247        state.backtracking--;
15248        state.failed=false;
15249        return success;
15250    }
15251    public final boolean synpred157_Java() {
15252        state.backtracking++;
15253        dbg.beginBacktrack(state.backtracking);
15254        int start = input.mark();
15255        try {
15256            synpred157_Java_fragment(); // can never throw exception
15257        } catch (RecognitionException re) {
15258            System.err.println("impossible: "+re);
15259        }
15260        boolean success = !state.failed;
15261        input.rewind(start);
15262        dbg.endBacktrack(state.backtracking, success);
15263        state.backtracking--;
15264        state.failed=false;
15265        return success;
15266    }
15267    public final boolean synpred224_Java() {
15268        state.backtracking++;
15269        dbg.beginBacktrack(state.backtracking);
15270        int start = input.mark();
15271        try {
15272            synpred224_Java_fragment(); // can never throw exception
15273        } catch (RecognitionException re) {
15274            System.err.println("impossible: "+re);
15275        }
15276        boolean success = !state.failed;
15277        input.rewind(start);
15278        dbg.endBacktrack(state.backtracking, success);
15279        state.backtracking--;
15280        state.failed=false;
15281        return success;
15282    }
15283    public final boolean synpred211_Java() {
15284        state.backtracking++;
15285        dbg.beginBacktrack(state.backtracking);
15286        int start = input.mark();
15287        try {
15288            synpred211_Java_fragment(); // can never throw exception
15289        } catch (RecognitionException re) {
15290            System.err.println("impossible: "+re);
15291        }
15292        boolean success = !state.failed;
15293        input.rewind(start);
15294        dbg.endBacktrack(state.backtracking, success);
15295        state.backtracking--;
15296        state.failed=false;
15297        return success;
15298    }
15299    public final boolean synpred121_Java() {
15300        state.backtracking++;
15301        dbg.beginBacktrack(state.backtracking);
15302        int start = input.mark();
15303        try {
15304            synpred121_Java_fragment(); // can never throw exception
15305        } catch (RecognitionException re) {
15306            System.err.println("impossible: "+re);
15307        }
15308        boolean success = !state.failed;
15309        input.rewind(start);
15310        dbg.endBacktrack(state.backtracking, success);
15311        state.backtracking--;
15312        state.failed=false;
15313        return success;
15314    }
15315    public final boolean synpred239_Java() {
15316        state.backtracking++;
15317        dbg.beginBacktrack(state.backtracking);
15318        int start = input.mark();
15319        try {
15320            synpred239_Java_fragment(); // can never throw exception
15321        } catch (RecognitionException re) {
15322            System.err.println("impossible: "+re);
15323        }
15324        boolean success = !state.failed;
15325        input.rewind(start);
15326        dbg.endBacktrack(state.backtracking, success);
15327        state.backtracking--;
15328        state.failed=false;
15329        return success;
15330    }
15331    public final boolean synpred69_Java() {
15332        state.backtracking++;
15333        dbg.beginBacktrack(state.backtracking);
15334        int start = input.mark();
15335        try {
15336            synpred69_Java_fragment(); // can never throw exception
15337        } catch (RecognitionException re) {
15338            System.err.println("impossible: "+re);
15339        }
15340        boolean success = !state.failed;
15341        input.rewind(start);
15342        dbg.endBacktrack(state.backtracking, success);
15343        state.backtracking--;
15344        state.failed=false;
15345        return success;
15346    }
15347    public final boolean synpred202_Java() {
15348        state.backtracking++;
15349        dbg.beginBacktrack(state.backtracking);
15350        int start = input.mark();
15351        try {
15352            synpred202_Java_fragment(); // can never throw exception
15353        } catch (RecognitionException re) {
15354            System.err.println("impossible: "+re);
15355        }
15356        boolean success = !state.failed;
15357        input.rewind(start);
15358        dbg.endBacktrack(state.backtracking, success);
15359        state.backtracking--;
15360        state.failed=false;
15361        return success;
15362    }
15363    public final boolean synpred154_Java() {
15364        state.backtracking++;
15365        dbg.beginBacktrack(state.backtracking);
15366        int start = input.mark();
15367        try {
15368            synpred154_Java_fragment(); // can never throw exception
15369        } catch (RecognitionException re) {
15370            System.err.println("impossible: "+re);
15371        }
15372        boolean success = !state.failed;
15373        input.rewind(start);
15374        dbg.endBacktrack(state.backtracking, success);
15375        state.backtracking--;
15376        state.failed=false;
15377        return success;
15378    }
15379    public final boolean synpred71_Java() {
15380        state.backtracking++;
15381        dbg.beginBacktrack(state.backtracking);
15382        int start = input.mark();
15383        try {
15384            synpred71_Java_fragment(); // can never throw exception
15385        } catch (RecognitionException re) {
15386            System.err.println("impossible: "+re);
15387        }
15388        boolean success = !state.failed;
15389        input.rewind(start);
15390        dbg.endBacktrack(state.backtracking, success);
15391        state.backtracking--;
15392        state.failed=false;
15393        return success;
15394    }
15395    public final boolean synpred133_Java() {
15396        state.backtracking++;
15397        dbg.beginBacktrack(state.backtracking);
15398        int start = input.mark();
15399        try {
15400            synpred133_Java_fragment(); // can never throw exception
15401        } catch (RecognitionException re) {
15402            System.err.println("impossible: "+re);
15403        }
15404        boolean success = !state.failed;
15405        input.rewind(start);
15406        dbg.endBacktrack(state.backtracking, success);
15407        state.backtracking--;
15408        state.failed=false;
15409        return success;
15410    }
15411    public final boolean synpred125_Java() {
15412        state.backtracking++;
15413        dbg.beginBacktrack(state.backtracking);
15414        int start = input.mark();
15415        try {
15416            synpred125_Java_fragment(); // can never throw exception
15417        } catch (RecognitionException re) {
15418            System.err.println("impossible: "+re);
15419        }
15420        boolean success = !state.failed;
15421        input.rewind(start);
15422        dbg.endBacktrack(state.backtracking, success);
15423        state.backtracking--;
15424        state.failed=false;
15425        return success;
15426    }
15427    public final boolean synpred132_Java() {
15428        state.backtracking++;
15429        dbg.beginBacktrack(state.backtracking);
15430        int start = input.mark();
15431        try {
15432            synpred132_Java_fragment(); // can never throw exception
15433        } catch (RecognitionException re) {
15434            System.err.println("impossible: "+re);
15435        }
15436        boolean success = !state.failed;
15437        input.rewind(start);
15438        dbg.endBacktrack(state.backtracking, success);
15439        state.backtracking--;
15440        state.failed=false;
15441        return success;
15442    }
15443    public final boolean synpred119_Java() {
15444        state.backtracking++;
15445        dbg.beginBacktrack(state.backtracking);
15446        int start = input.mark();
15447        try {
15448            synpred119_Java_fragment(); // can never throw exception
15449        } catch (RecognitionException re) {
15450            System.err.println("impossible: "+re);
15451        }
15452        boolean success = !state.failed;
15453        input.rewind(start);
15454        dbg.endBacktrack(state.backtracking, success);
15455        state.backtracking--;
15456        state.failed=false;
15457        return success;
15458    }
15459    public final boolean synpred54_Java() {
15460        state.backtracking++;
15461        dbg.beginBacktrack(state.backtracking);
15462        int start = input.mark();
15463        try {
15464            synpred54_Java_fragment(); // can never throw exception
15465        } catch (RecognitionException re) {
15466            System.err.println("impossible: "+re);
15467        }
15468        boolean success = !state.failed;
15469        input.rewind(start);
15470        dbg.endBacktrack(state.backtracking, success);
15471        state.backtracking--;
15472        state.failed=false;
15473        return success;
15474    }
15475    public final boolean synpred148_Java() {
15476        state.backtracking++;
15477        dbg.beginBacktrack(state.backtracking);
15478        int start = input.mark();
15479        try {
15480            synpred148_Java_fragment(); // can never throw exception
15481        } catch (RecognitionException re) {
15482            System.err.println("impossible: "+re);
15483        }
15484        boolean success = !state.failed;
15485        input.rewind(start);
15486        dbg.endBacktrack(state.backtracking, success);
15487        state.backtracking--;
15488        state.failed=false;
15489        return success;
15490    }
15491    public final boolean synpred117_Java() {
15492        state.backtracking++;
15493        dbg.beginBacktrack(state.backtracking);
15494        int start = input.mark();
15495        try {
15496            synpred117_Java_fragment(); // can never throw exception
15497        } catch (RecognitionException re) {
15498            System.err.println("impossible: "+re);
15499        }
15500        boolean success = !state.failed;
15501        input.rewind(start);
15502        dbg.endBacktrack(state.backtracking, success);
15503        state.backtracking--;
15504        state.failed=false;
15505        return success;
15506    }
15507    public final boolean synpred2_Java() {
15508        state.backtracking++;
15509        dbg.beginBacktrack(state.backtracking);
15510        int start = input.mark();
15511        try {
15512            synpred2_Java_fragment(); // can never throw exception
15513        } catch (RecognitionException re) {
15514            System.err.println("impossible: "+re);
15515        }
15516        boolean success = !state.failed;
15517        input.rewind(start);
15518        dbg.endBacktrack(state.backtracking, success);
15519        state.backtracking--;
15520        state.failed=false;
15521        return success;
15522    }
15523    public final boolean synpred130_Java() {
15524        state.backtracking++;
15525        dbg.beginBacktrack(state.backtracking);
15526        int start = input.mark();
15527        try {
15528            synpred130_Java_fragment(); // can never throw exception
15529        } catch (RecognitionException re) {
15530            System.err.println("impossible: "+re);
15531        }
15532        boolean success = !state.failed;
15533        input.rewind(start);
15534        dbg.endBacktrack(state.backtracking, success);
15535        state.backtracking--;
15536        state.failed=false;
15537        return success;
15538    }
15539    public final boolean synpred126_Java() {
15540        state.backtracking++;
15541        dbg.beginBacktrack(state.backtracking);
15542        int start = input.mark();
15543        try {
15544            synpred126_Java_fragment(); // can never throw exception
15545        } catch (RecognitionException re) {
15546            System.err.println("impossible: "+re);
15547        }
15548        boolean success = !state.failed;
15549        input.rewind(start);
15550        dbg.endBacktrack(state.backtracking, success);
15551        state.backtracking--;
15552        state.failed=false;
15553        return success;
15554    }
15555    public final boolean synpred59_Java() {
15556        state.backtracking++;
15557        dbg.beginBacktrack(state.backtracking);
15558        int start = input.mark();
15559        try {
15560            synpred59_Java_fragment(); // can never throw exception
15561        } catch (RecognitionException re) {
15562            System.err.println("impossible: "+re);
15563        }
15564        boolean success = !state.failed;
15565        input.rewind(start);
15566        dbg.endBacktrack(state.backtracking, success);
15567        state.backtracking--;
15568        state.failed=false;
15569        return success;
15570    }
15571    public final boolean synpred212_Java() {
15572        state.backtracking++;
15573        dbg.beginBacktrack(state.backtracking);
15574        int start = input.mark();
15575        try {
15576            synpred212_Java_fragment(); // can never throw exception
15577        } catch (RecognitionException re) {
15578            System.err.println("impossible: "+re);
15579        }
15580        boolean success = !state.failed;
15581        input.rewind(start);
15582        dbg.endBacktrack(state.backtracking, success);
15583        state.backtracking--;
15584        state.failed=false;
15585        return success;
15586    }
15587    public final boolean synpred161_Java() {
15588        state.backtracking++;
15589        dbg.beginBacktrack(state.backtracking);
15590        int start = input.mark();
15591        try {
15592            synpred161_Java_fragment(); // can never throw exception
15593        } catch (RecognitionException re) {
15594            System.err.println("impossible: "+re);
15595        }
15596        boolean success = !state.failed;
15597        input.rewind(start);
15598        dbg.endBacktrack(state.backtracking, success);
15599        state.backtracking--;
15600        state.failed=false;
15601        return success;
15602    }
15603    public final boolean synpred57_Java() {
15604        state.backtracking++;
15605        dbg.beginBacktrack(state.backtracking);
15606        int start = input.mark();
15607        try {
15608            synpred57_Java_fragment(); // can never throw exception
15609        } catch (RecognitionException re) {
15610            System.err.println("impossible: "+re);
15611        }
15612        boolean success = !state.failed;
15613        input.rewind(start);
15614        dbg.endBacktrack(state.backtracking, success);
15615        state.backtracking--;
15616        state.failed=false;
15617        return success;
15618    }
15619    public final boolean synpred209_Java() {
15620        state.backtracking++;
15621        dbg.beginBacktrack(state.backtracking);
15622        int start = input.mark();
15623        try {
15624            synpred209_Java_fragment(); // can never throw exception
15625        } catch (RecognitionException re) {
15626            System.err.println("impossible: "+re);
15627        }
15628        boolean success = !state.failed;
15629        input.rewind(start);
15630        dbg.endBacktrack(state.backtracking, success);
15631        state.backtracking--;
15632        state.failed=false;
15633        return success;
15634    }
15635    public final boolean synpred68_Java() {
15636        state.backtracking++;
15637        dbg.beginBacktrack(state.backtracking);
15638        int start = input.mark();
15639        try {
15640            synpred68_Java_fragment(); // can never throw exception
15641        } catch (RecognitionException re) {
15642            System.err.println("impossible: "+re);
15643        }
15644        boolean success = !state.failed;
15645        input.rewind(start);
15646        dbg.endBacktrack(state.backtracking, success);
15647        state.backtracking--;
15648        state.failed=false;
15649        return success;
15650    }
15651    public final boolean synpred53_Java() {
15652        state.backtracking++;
15653        dbg.beginBacktrack(state.backtracking);
15654        int start = input.mark();
15655        try {
15656            synpred53_Java_fragment(); // can never throw exception
15657        } catch (RecognitionException re) {
15658            System.err.println("impossible: "+re);
15659        }
15660        boolean success = !state.failed;
15661        input.rewind(start);
15662        dbg.endBacktrack(state.backtracking, success);
15663        state.backtracking--;
15664        state.failed=false;
15665        return success;
15666    }
15667    public final boolean synpred52_Java() {
15668        state.backtracking++;
15669        dbg.beginBacktrack(state.backtracking);
15670        int start = input.mark();
15671        try {
15672            synpred52_Java_fragment(); // can never throw exception
15673        } catch (RecognitionException re) {
15674            System.err.println("impossible: "+re);
15675        }
15676        boolean success = !state.failed;
15677        input.rewind(start);
15678        dbg.endBacktrack(state.backtracking, success);
15679        state.backtracking--;
15680        state.failed=false;
15681        return success;
15682    }
15683    public final boolean synpred236_Java() {
15684        state.backtracking++;
15685        dbg.beginBacktrack(state.backtracking);
15686        int start = input.mark();
15687        try {
15688            synpred236_Java_fragment(); // can never throw exception
15689        } catch (RecognitionException re) {
15690            System.err.println("impossible: "+re);
15691        }
15692        boolean success = !state.failed;
15693        input.rewind(start);
15694        dbg.endBacktrack(state.backtracking, success);
15695        state.backtracking--;
15696        state.failed=false;
15697        return success;
15698    }
15699    public final boolean synpred12_Java() {
15700        state.backtracking++;
15701        dbg.beginBacktrack(state.backtracking);
15702        int start = input.mark();
15703        try {
15704            synpred12_Java_fragment(); // can never throw exception
15705        } catch (RecognitionException re) {
15706            System.err.println("impossible: "+re);
15707        }
15708        boolean success = !state.failed;
15709        input.rewind(start);
15710        dbg.endBacktrack(state.backtracking, success);
15711        state.backtracking--;
15712        state.failed=false;
15713        return success;
15714    }
15715    public final boolean synpred149_Java() {
15716        state.backtracking++;
15717        dbg.beginBacktrack(state.backtracking);
15718        int start = input.mark();
15719        try {
15720            synpred149_Java_fragment(); // can never throw exception
15721        } catch (RecognitionException re) {
15722            System.err.println("impossible: "+re);
15723        }
15724        boolean success = !state.failed;
15725        input.rewind(start);
15726        dbg.endBacktrack(state.backtracking, success);
15727        state.backtracking--;
15728        state.failed=false;
15729        return success;
15730    }
15731    public final boolean synpred120_Java() {
15732        state.backtracking++;
15733        dbg.beginBacktrack(state.backtracking);
15734        int start = input.mark();
15735        try {
15736            synpred120_Java_fragment(); // can never throw exception
15737        } catch (RecognitionException re) {
15738            System.err.println("impossible: "+re);
15739        }
15740        boolean success = !state.failed;
15741        input.rewind(start);
15742        dbg.endBacktrack(state.backtracking, success);
15743        state.backtracking--;
15744        state.failed=false;
15745        return success;
15746    }
15747    public final boolean synpred122_Java() {
15748        state.backtracking++;
15749        dbg.beginBacktrack(state.backtracking);
15750        int start = input.mark();
15751        try {
15752            synpred122_Java_fragment(); // can never throw exception
15753        } catch (RecognitionException re) {
15754            System.err.println("impossible: "+re);
15755        }
15756        boolean success = !state.failed;
15757        input.rewind(start);
15758        dbg.endBacktrack(state.backtracking, success);
15759        state.backtracking--;
15760        state.failed=false;
15761        return success;
15762    }
15763    public final boolean synpred240_Java() {
15764        state.backtracking++;
15765        dbg.beginBacktrack(state.backtracking);
15766        int start = input.mark();
15767        try {
15768            synpred240_Java_fragment(); // can never throw exception
15769        } catch (RecognitionException re) {
15770            System.err.println("impossible: "+re);
15771        }
15772        boolean success = !state.failed;
15773        input.rewind(start);
15774        dbg.endBacktrack(state.backtracking, success);
15775        state.backtracking--;
15776        state.failed=false;
15777        return success;
15778    }
15779    public final boolean synpred206_Java() {
15780        state.backtracking++;
15781        dbg.beginBacktrack(state.backtracking);
15782        int start = input.mark();
15783        try {
15784            synpred206_Java_fragment(); // can never throw exception
15785        } catch (RecognitionException re) {
15786            System.err.println("impossible: "+re);
15787        }
15788        boolean success = !state.failed;
15789        input.rewind(start);
15790        dbg.endBacktrack(state.backtracking, success);
15791        state.backtracking--;
15792        state.failed=false;
15793        return success;
15794    }
15795    public final boolean synpred70_Java() {
15796        state.backtracking++;
15797        dbg.beginBacktrack(state.backtracking);
15798        int start = input.mark();
15799        try {
15800            synpred70_Java_fragment(); // can never throw exception
15801        } catch (RecognitionException re) {
15802            System.err.println("impossible: "+re);
15803        }
15804        boolean success = !state.failed;
15805        input.rewind(start);
15806        dbg.endBacktrack(state.backtracking, success);
15807        state.backtracking--;
15808        state.failed=false;
15809        return success;
15810    }
15811    public final boolean synpred27_Java() {
15812        state.backtracking++;
15813        dbg.beginBacktrack(state.backtracking);
15814        int start = input.mark();
15815        try {
15816            synpred27_Java_fragment(); // can never throw exception
15817        } catch (RecognitionException re) {
15818            System.err.println("impossible: "+re);
15819        }
15820        boolean success = !state.failed;
15821        input.rewind(start);
15822        dbg.endBacktrack(state.backtracking, success);
15823        state.backtracking--;
15824        state.failed=false;
15825        return success;
15826    }
15827    public final boolean synpred96_Java() {
15828        state.backtracking++;
15829        dbg.beginBacktrack(state.backtracking);
15830        int start = input.mark();
15831        try {
15832            synpred96_Java_fragment(); // can never throw exception
15833        } catch (RecognitionException re) {
15834            System.err.println("impossible: "+re);
15835        }
15836        boolean success = !state.failed;
15837        input.rewind(start);
15838        dbg.endBacktrack(state.backtracking, success);
15839        state.backtracking--;
15840        state.failed=false;
15841        return success;
15842    }
15843    public final boolean synpred153_Java() {
15844        state.backtracking++;
15845        dbg.beginBacktrack(state.backtracking);
15846        int start = input.mark();
15847        try {
15848            synpred153_Java_fragment(); // can never throw exception
15849        } catch (RecognitionException re) {
15850            System.err.println("impossible: "+re);
15851        }
15852        boolean success = !state.failed;
15853        input.rewind(start);
15854        dbg.endBacktrack(state.backtracking, success);
15855        state.backtracking--;
15856        state.failed=false;
15857        return success;
15858    }
15859    public final boolean synpred99_Java() {
15860        state.backtracking++;
15861        dbg.beginBacktrack(state.backtracking);
15862        int start = input.mark();
15863        try {
15864            synpred99_Java_fragment(); // can never throw exception
15865        } catch (RecognitionException re) {
15866            System.err.println("impossible: "+re);
15867        }
15868        boolean success = !state.failed;
15869        input.rewind(start);
15870        dbg.endBacktrack(state.backtracking, success);
15871        state.backtracking--;
15872        state.failed=false;
15873        return success;
15874    }
15875    public final boolean synpred103_Java() {
15876        state.backtracking++;
15877        dbg.beginBacktrack(state.backtracking);
15878        int start = input.mark();
15879        try {
15880            synpred103_Java_fragment(); // can never throw exception
15881        } catch (RecognitionException re) {
15882            System.err.println("impossible: "+re);
15883        }
15884        boolean success = !state.failed;
15885        input.rewind(start);
15886        dbg.endBacktrack(state.backtracking, success);
15887        state.backtracking--;
15888        state.failed=false;
15889        return success;
15890    }
15891    public final boolean synpred237_Java() {
15892        state.backtracking++;
15893        dbg.beginBacktrack(state.backtracking);
15894        int start = input.mark();
15895        try {
15896            synpred237_Java_fragment(); // can never throw exception
15897        } catch (RecognitionException re) {
15898            System.err.println("impossible: "+re);
15899        }
15900        boolean success = !state.failed;
15901        input.rewind(start);
15902        dbg.endBacktrack(state.backtracking, success);
15903        state.backtracking--;
15904        state.failed=false;
15905        return success;
15906    }
15907    public final boolean synpred118_Java() {
15908        state.backtracking++;
15909        dbg.beginBacktrack(state.backtracking);
15910        int start = input.mark();
15911        try {
15912            synpred118_Java_fragment(); // can never throw exception
15913        } catch (RecognitionException re) {
15914            System.err.println("impossible: "+re);
15915        }
15916        boolean success = !state.failed;
15917        input.rewind(start);
15918        dbg.endBacktrack(state.backtracking, success);
15919        state.backtracking--;
15920        state.failed=false;
15921        return success;
15922    }
15923    public final boolean synpred208_Java() {
15924        state.backtracking++;
15925        dbg.beginBacktrack(state.backtracking);
15926        int start = input.mark();
15927        try {
15928            synpred208_Java_fragment(); // can never throw exception
15929        } catch (RecognitionException re) {
15930            System.err.println("impossible: "+re);
15931        }
15932        boolean success = !state.failed;
15933        input.rewind(start);
15934        dbg.endBacktrack(state.backtracking, success);
15935        state.backtracking--;
15936        state.failed=false;
15937        return success;
15938    }
15939
15940
15941    protected DFA2 dfa2 = new DFA2(this);
15942    protected DFA12 dfa12 = new DFA12(this);
15943    protected DFA13 dfa13 = new DFA13(this);
15944    protected DFA15 dfa15 = new DFA15(this);
15945    protected DFA31 dfa31 = new DFA31(this);
15946    protected DFA39 dfa39 = new DFA39(this);
15947    protected DFA49 dfa49 = new DFA49(this);
15948    protected DFA42 dfa42 = new DFA42(this);
15949    protected DFA53 dfa53 = new DFA53(this);
15950    protected DFA76 dfa76 = new DFA76(this);
15951    protected DFA87 dfa87 = new DFA87(this);
15952    protected DFA90 dfa90 = new DFA90(this);
15953    protected DFA98 dfa98 = new DFA98(this);
15954    protected DFA109 dfa109 = new DFA109(this);
15955    protected DFA112 dfa112 = new DFA112(this);
15956    protected DFA130 dfa130 = new DFA130(this);
15957    protected DFA133 dfa133 = new DFA133(this);
15958    protected DFA135 dfa135 = new DFA135(this);
15959    protected DFA143 dfa143 = new DFA143(this);
15960    protected DFA142 dfa142 = new DFA142(this);
15961    protected DFA148 dfa148 = new DFA148(this);
15962    protected DFA171 dfa171 = new DFA171(this);
15963    static final String DFA2_eotS =
15964        "\24\uffff";
15965    static final String DFA2_eofS =
15966        "\1\3\23\uffff";
15967    static final String DFA2_minS =
15968        "\1\34\1\0\22\uffff";
15969    static final String DFA2_maxS =
15970        "\1\162\1\0\22\uffff";
15971    static final String DFA2_acceptS =
15972        "\2\uffff\1\1\1\2\20\uffff";
15973    static final String DFA2_specialS =
15974        "\1\uffff\1\0\22\uffff}>";
15975    static final String[] DFA2_transitionS = {
15976            "\1\3\7\uffff\1\3\6\uffff\1\3\1\uffff\1\3\6\uffff\1\3\2\uffff"+
15977            "\1\3\1\uffff\1\3\1\uffff\1\2\3\3\2\uffff\2\3\2\uffff\1\3\3\uffff"+
15978            "\1\3\2\uffff\1\3\7\uffff\1\3\35\uffff\1\1",
15979            "\1\uffff",
15980            "",
15981            "",
15982            "",
15983            "",
15984            "",
15985            "",
15986            "",
15987            "",
15988            "",
15989            "",
15990            "",
15991            "",
15992            "",
15993            "",
15994            "",
15995            "",
15996            "",
15997            ""
15998    };
15999
16000    static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
16001    static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
16002    static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
16003    static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
16004    static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
16005    static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
16006    static final short[][] DFA2_transition;
16007
16008    static {
16009        int numStates = DFA2_transitionS.length;
16010        DFA2_transition = new short[numStates][];
16011        for (int i=0; i<numStates; i++) {
16012            DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
16013        }
16014    }
16015
16016    class DFA2 extends DFA {
16017
16018        public DFA2(BaseRecognizer recognizer) {
16019            this.recognizer = recognizer;
16020            this.decisionNumber = 2;
16021            this.eot = DFA2_eot;
16022            this.eof = DFA2_eof;
16023            this.min = DFA2_min;
16024            this.max = DFA2_max;
16025            this.accept = DFA2_accept;
16026            this.special = DFA2_special;
16027            this.transition = DFA2_transition;
16028        }
16029        public String getDescription() {
16030            return "298:9: ( ( annotations )? packageDeclaration )?";
16031        }
16032        public void error(NoViableAltException nvae) {
16033            dbg.recognitionException(nvae);
16034        }
16035        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
16036            TokenStream input = (TokenStream)_input;
16037		int _s = s;
16038            switch ( s ) {
16039                    case 0 :
16040                        int LA2_1 = input.LA(1);
16041
16042
16043                        int index2_1 = input.index();
16044                        input.rewind();
16045                        s = -1;
16046                        if ( (synpred2_Java()) ) {s = 2;}
16047
16048                        else if ( (true) ) {s = 3;}
16049
16050
16051                        input.seek(index2_1);
16052                        if ( s>=0 ) return s;
16053                        break;
16054            }
16055            if (state.backtracking>0) {state.failed=true; return -1;}
16056            NoViableAltException nvae =
16057                new NoViableAltException(getDescription(), 2, _s, input);
16058            error(nvae);
16059            throw nvae;
16060        }
16061    }
16062    static final String DFA12_eotS =
16063        "\20\uffff";
16064    static final String DFA12_eofS =
16065        "\20\uffff";
16066    static final String DFA12_minS =
16067        "\1\34\14\0\3\uffff";
16068    static final String DFA12_maxS =
16069        "\1\162\14\0\3\uffff";
16070    static final String DFA12_acceptS =
16071        "\15\uffff\1\1\1\uffff\1\2";
16072    static final String DFA12_specialS =
16073        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\3\uffff}>";
16074    static final String[] DFA12_transitionS = {
16075            "\1\6\7\uffff\1\15\6\uffff\1\15\1\uffff\1\7\11\uffff\1\17\1\uffff"+
16076            "\1\10\2\uffff\1\4\1\3\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff"+
16077            "\1\12\2\uffff\1\13\45\uffff\1\1",
16078            "\1\uffff",
16079            "\1\uffff",
16080            "\1\uffff",
16081            "\1\uffff",
16082            "\1\uffff",
16083            "\1\uffff",
16084            "\1\uffff",
16085            "\1\uffff",
16086            "\1\uffff",
16087            "\1\uffff",
16088            "\1\uffff",
16089            "\1\uffff",
16090            "",
16091            "",
16092            ""
16093    };
16094
16095    static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS);
16096    static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS);
16097    static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS);
16098    static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS);
16099    static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS);
16100    static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS);
16101    static final short[][] DFA12_transition;
16102
16103    static {
16104        int numStates = DFA12_transitionS.length;
16105        DFA12_transition = new short[numStates][];
16106        for (int i=0; i<numStates; i++) {
16107            DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]);
16108        }
16109    }
16110
16111    class DFA12 extends DFA {
16112
16113        public DFA12(BaseRecognizer recognizer) {
16114            this.recognizer = recognizer;
16115            this.decisionNumber = 12;
16116            this.eot = DFA12_eot;
16117            this.eof = DFA12_eof;
16118            this.min = DFA12_min;
16119            this.max = DFA12_max;
16120            this.accept = DFA12_accept;
16121            this.special = DFA12_special;
16122            this.transition = DFA12_transition;
16123        }
16124        public String getDescription() {
16125            return "341:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );";
16126        }
16127        public void error(NoViableAltException nvae) {
16128            dbg.recognitionException(nvae);
16129        }
16130        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
16131            TokenStream input = (TokenStream)_input;
16132		int _s = s;
16133            switch ( s ) {
16134                    case 0 :
16135                        int LA12_1 = input.LA(1);
16136
16137
16138                        int index12_1 = input.index();
16139                        input.rewind();
16140                        s = -1;
16141                        if ( (synpred12_Java()) ) {s = 13;}
16142
16143                        else if ( (true) ) {s = 15;}
16144
16145
16146                        input.seek(index12_1);
16147                        if ( s>=0 ) return s;
16148                        break;
16149                    case 1 :
16150                        int LA12_2 = input.LA(1);
16151
16152
16153                        int index12_2 = input.index();
16154                        input.rewind();
16155                        s = -1;
16156                        if ( (synpred12_Java()) ) {s = 13;}
16157
16158                        else if ( (true) ) {s = 15;}
16159
16160
16161                        input.seek(index12_2);
16162                        if ( s>=0 ) return s;
16163                        break;
16164                    case 2 :
16165                        int LA12_3 = input.LA(1);
16166
16167
16168                        int index12_3 = input.index();
16169                        input.rewind();
16170                        s = -1;
16171                        if ( (synpred12_Java()) ) {s = 13;}
16172
16173                        else if ( (true) ) {s = 15;}
16174
16175
16176                        input.seek(index12_3);
16177                        if ( s>=0 ) return s;
16178                        break;
16179                    case 3 :
16180                        int LA12_4 = input.LA(1);
16181
16182
16183                        int index12_4 = input.index();
16184                        input.rewind();
16185                        s = -1;
16186                        if ( (synpred12_Java()) ) {s = 13;}
16187
16188                        else if ( (true) ) {s = 15;}
16189
16190
16191                        input.seek(index12_4);
16192                        if ( s>=0 ) return s;
16193                        break;
16194                    case 4 :
16195                        int LA12_5 = input.LA(1);
16196
16197
16198                        int index12_5 = input.index();
16199                        input.rewind();
16200                        s = -1;
16201                        if ( (synpred12_Java()) ) {s = 13;}
16202
16203                        else if ( (true) ) {s = 15;}
16204
16205
16206                        input.seek(index12_5);
16207                        if ( s>=0 ) return s;
16208                        break;
16209                    case 5 :
16210                        int LA12_6 = input.LA(1);
16211
16212
16213                        int index12_6 = input.index();
16214                        input.rewind();
16215                        s = -1;
16216                        if ( (synpred12_Java()) ) {s = 13;}
16217
16218                        else if ( (true) ) {s = 15;}
16219
16220
16221                        input.seek(index12_6);
16222                        if ( s>=0 ) return s;
16223                        break;
16224                    case 6 :
16225                        int LA12_7 = input.LA(1);
16226
16227
16228                        int index12_7 = input.index();
16229                        input.rewind();
16230                        s = -1;
16231                        if ( (synpred12_Java()) ) {s = 13;}
16232
16233                        else if ( (true) ) {s = 15;}
16234
16235
16236                        input.seek(index12_7);
16237                        if ( s>=0 ) return s;
16238                        break;
16239                    case 7 :
16240                        int LA12_8 = input.LA(1);
16241
16242
16243                        int index12_8 = input.index();
16244                        input.rewind();
16245                        s = -1;
16246                        if ( (synpred12_Java()) ) {s = 13;}
16247
16248                        else if ( (true) ) {s = 15;}
16249
16250
16251                        input.seek(index12_8);
16252                        if ( s>=0 ) return s;
16253                        break;
16254                    case 8 :
16255                        int LA12_9 = input.LA(1);
16256
16257
16258                        int index12_9 = input.index();
16259                        input.rewind();
16260                        s = -1;
16261                        if ( (synpred12_Java()) ) {s = 13;}
16262
16263                        else if ( (true) ) {s = 15;}
16264
16265
16266                        input.seek(index12_9);
16267                        if ( s>=0 ) return s;
16268                        break;
16269                    case 9 :
16270                        int LA12_10 = input.LA(1);
16271
16272
16273                        int index12_10 = input.index();
16274                        input.rewind();
16275                        s = -1;
16276                        if ( (synpred12_Java()) ) {s = 13;}
16277
16278                        else if ( (true) ) {s = 15;}
16279
16280
16281                        input.seek(index12_10);
16282                        if ( s>=0 ) return s;
16283                        break;
16284                    case 10 :
16285                        int LA12_11 = input.LA(1);
16286
16287
16288                        int index12_11 = input.index();
16289                        input.rewind();
16290                        s = -1;
16291                        if ( (synpred12_Java()) ) {s = 13;}
16292
16293                        else if ( (true) ) {s = 15;}
16294
16295
16296                        input.seek(index12_11);
16297                        if ( s>=0 ) return s;
16298                        break;
16299                    case 11 :
16300                        int LA12_12 = input.LA(1);
16301
16302
16303                        int index12_12 = input.index();
16304                        input.rewind();
16305                        s = -1;
16306                        if ( (synpred12_Java()) ) {s = 13;}
16307
16308                        else if ( (true) ) {s = 15;}
16309
16310
16311                        input.seek(index12_12);
16312                        if ( s>=0 ) return s;
16313                        break;
16314            }
16315            if (state.backtracking>0) {state.failed=true; return -1;}
16316            NoViableAltException nvae =
16317                new NoViableAltException(getDescription(), 12, _s, input);
16318            error(nvae);
16319            throw nvae;
16320        }
16321    }
16322    static final String DFA13_eotS =
16323        "\17\uffff";
16324    static final String DFA13_eofS =
16325        "\17\uffff";
16326    static final String DFA13_minS =
16327        "\1\4\1\uffff\1\4\14\uffff";
16328    static final String DFA13_maxS =
16329        "\1\165\1\uffff\1\67\14\uffff";
16330    static final String DFA13_acceptS =
16331        "\1\uffff\1\15\1\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13"+
16332        "\1\14\1\1";
16333    static final String DFA13_specialS =
16334        "\17\uffff}>";
16335    static final String[] DFA13_transitionS = {
16336            "\1\1\27\uffff\1\7\1\uffff\1\1\1\uffff\1\1\2\uffff\2\1\4\uffff"+
16337            "\1\1\1\uffff\1\1\1\uffff\1\10\1\uffff\1\1\6\uffff\3\1\1\11\2"+
16338            "\uffff\1\5\1\4\1\3\1\uffff\1\1\1\6\1\15\2\uffff\1\12\3\uffff"+
16339            "\1\13\1\uffff\1\1\1\14\45\uffff\1\2\2\uffff\1\1",
16340            "",
16341            "\1\16\62\uffff\1\1",
16342            "",
16343            "",
16344            "",
16345            "",
16346            "",
16347            "",
16348            "",
16349            "",
16350            "",
16351            "",
16352            "",
16353            ""
16354    };
16355
16356    static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
16357    static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
16358    static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS);
16359    static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS);
16360    static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
16361    static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS);
16362    static final short[][] DFA13_transition;
16363
16364    static {
16365        int numStates = DFA13_transitionS.length;
16366        DFA13_transition = new short[numStates][];
16367        for (int i=0; i<numStates; i++) {
16368            DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]);
16369        }
16370    }
16371
16372    class DFA13 extends DFA {
16373
16374        public DFA13(BaseRecognizer recognizer) {
16375            this.recognizer = recognizer;
16376            this.decisionNumber = 13;
16377            this.eot = DFA13_eot;
16378            this.eof = DFA13_eof;
16379            this.min = DFA13_min;
16380            this.max = DFA13_max;
16381            this.accept = DFA13_accept;
16382            this.special = DFA13_special;
16383            this.transition = DFA13_transition;
16384        }
16385        public String getDescription() {
16386            return "()* loopback of 349:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*";
16387        }
16388        public void error(NoViableAltException nvae) {
16389            dbg.recognitionException(nvae);
16390        }
16391    }
16392    static final String DFA15_eotS =
16393        "\17\uffff";
16394    static final String DFA15_eofS =
16395        "\17\uffff";
16396    static final String DFA15_minS =
16397        "\1\34\14\0\2\uffff";
16398    static final String DFA15_maxS =
16399        "\1\162\14\0\2\uffff";
16400    static final String DFA15_acceptS =
16401        "\15\uffff\1\1\1\2";
16402    static final String DFA15_specialS =
16403        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\2\uffff}>";
16404    static final String[] DFA15_transitionS = {
16405            "\1\6\7\uffff\1\15\6\uffff\1\16\1\uffff\1\7\13\uffff\1\10\2\uffff"+
16406            "\1\4\1\3\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff\1\12\2\uffff"+
16407            "\1\13\45\uffff\1\1",
16408            "\1\uffff",
16409            "\1\uffff",
16410            "\1\uffff",
16411            "\1\uffff",
16412            "\1\uffff",
16413            "\1\uffff",
16414            "\1\uffff",
16415            "\1\uffff",
16416            "\1\uffff",
16417            "\1\uffff",
16418            "\1\uffff",
16419            "\1\uffff",
16420            "",
16421            ""
16422    };
16423
16424    static final short[] DFA15_eot = DFA.unpackEncodedString(DFA15_eotS);
16425    static final short[] DFA15_eof = DFA.unpackEncodedString(DFA15_eofS);
16426    static final char[] DFA15_min = DFA.unpackEncodedStringToUnsignedChars(DFA15_minS);
16427    static final char[] DFA15_max = DFA.unpackEncodedStringToUnsignedChars(DFA15_maxS);
16428    static final short[] DFA15_accept = DFA.unpackEncodedString(DFA15_acceptS);
16429    static final short[] DFA15_special = DFA.unpackEncodedString(DFA15_specialS);
16430    static final short[][] DFA15_transition;
16431
16432    static {
16433        int numStates = DFA15_transitionS.length;
16434        DFA15_transition = new short[numStates][];
16435        for (int i=0; i<numStates; i++) {
16436            DFA15_transition[i] = DFA.unpackEncodedString(DFA15_transitionS[i]);
16437        }
16438    }
16439
16440    class DFA15 extends DFA {
16441
16442        public DFA15(BaseRecognizer recognizer) {
16443            this.recognizer = recognizer;
16444            this.decisionNumber = 15;
16445            this.eot = DFA15_eot;
16446            this.eof = DFA15_eof;
16447            this.min = DFA15_min;
16448            this.max = DFA15_max;
16449            this.accept = DFA15_accept;
16450            this.special = DFA15_special;
16451            this.transition = DFA15_transition;
16452        }
16453        public String getDescription() {
16454            return "372:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );";
16455        }
16456        public void error(NoViableAltException nvae) {
16457            dbg.recognitionException(nvae);
16458        }
16459        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
16460            TokenStream input = (TokenStream)_input;
16461		int _s = s;
16462            switch ( s ) {
16463                    case 0 :
16464                        int LA15_1 = input.LA(1);
16465
16466
16467                        int index15_1 = input.index();
16468                        input.rewind();
16469                        s = -1;
16470                        if ( (synpred27_Java()) ) {s = 13;}
16471
16472                        else if ( (true) ) {s = 14;}
16473
16474
16475                        input.seek(index15_1);
16476                        if ( s>=0 ) return s;
16477                        break;
16478                    case 1 :
16479                        int LA15_2 = input.LA(1);
16480
16481
16482                        int index15_2 = input.index();
16483                        input.rewind();
16484                        s = -1;
16485                        if ( (synpred27_Java()) ) {s = 13;}
16486
16487                        else if ( (true) ) {s = 14;}
16488
16489
16490                        input.seek(index15_2);
16491                        if ( s>=0 ) return s;
16492                        break;
16493                    case 2 :
16494                        int LA15_3 = input.LA(1);
16495
16496
16497                        int index15_3 = input.index();
16498                        input.rewind();
16499                        s = -1;
16500                        if ( (synpred27_Java()) ) {s = 13;}
16501
16502                        else if ( (true) ) {s = 14;}
16503
16504
16505                        input.seek(index15_3);
16506                        if ( s>=0 ) return s;
16507                        break;
16508                    case 3 :
16509                        int LA15_4 = input.LA(1);
16510
16511
16512                        int index15_4 = input.index();
16513                        input.rewind();
16514                        s = -1;
16515                        if ( (synpred27_Java()) ) {s = 13;}
16516
16517                        else if ( (true) ) {s = 14;}
16518
16519
16520                        input.seek(index15_4);
16521                        if ( s>=0 ) return s;
16522                        break;
16523                    case 4 :
16524                        int LA15_5 = input.LA(1);
16525
16526
16527                        int index15_5 = input.index();
16528                        input.rewind();
16529                        s = -1;
16530                        if ( (synpred27_Java()) ) {s = 13;}
16531
16532                        else if ( (true) ) {s = 14;}
16533
16534
16535                        input.seek(index15_5);
16536                        if ( s>=0 ) return s;
16537                        break;
16538                    case 5 :
16539                        int LA15_6 = input.LA(1);
16540
16541
16542                        int index15_6 = input.index();
16543                        input.rewind();
16544                        s = -1;
16545                        if ( (synpred27_Java()) ) {s = 13;}
16546
16547                        else if ( (true) ) {s = 14;}
16548
16549
16550                        input.seek(index15_6);
16551                        if ( s>=0 ) return s;
16552                        break;
16553                    case 6 :
16554                        int LA15_7 = input.LA(1);
16555
16556
16557                        int index15_7 = input.index();
16558                        input.rewind();
16559                        s = -1;
16560                        if ( (synpred27_Java()) ) {s = 13;}
16561
16562                        else if ( (true) ) {s = 14;}
16563
16564
16565                        input.seek(index15_7);
16566                        if ( s>=0 ) return s;
16567                        break;
16568                    case 7 :
16569                        int LA15_8 = input.LA(1);
16570
16571
16572                        int index15_8 = input.index();
16573                        input.rewind();
16574                        s = -1;
16575                        if ( (synpred27_Java()) ) {s = 13;}
16576
16577                        else if ( (true) ) {s = 14;}
16578
16579
16580                        input.seek(index15_8);
16581                        if ( s>=0 ) return s;
16582                        break;
16583                    case 8 :
16584                        int LA15_9 = input.LA(1);
16585
16586
16587                        int index15_9 = input.index();
16588                        input.rewind();
16589                        s = -1;
16590                        if ( (synpred27_Java()) ) {s = 13;}
16591
16592                        else if ( (true) ) {s = 14;}
16593
16594
16595                        input.seek(index15_9);
16596                        if ( s>=0 ) return s;
16597                        break;
16598                    case 9 :
16599                        int LA15_10 = input.LA(1);
16600
16601
16602                        int index15_10 = input.index();
16603                        input.rewind();
16604                        s = -1;
16605                        if ( (synpred27_Java()) ) {s = 13;}
16606
16607                        else if ( (true) ) {s = 14;}
16608
16609
16610                        input.seek(index15_10);
16611                        if ( s>=0 ) return s;
16612                        break;
16613                    case 10 :
16614                        int LA15_11 = input.LA(1);
16615
16616
16617                        int index15_11 = input.index();
16618                        input.rewind();
16619                        s = -1;
16620                        if ( (synpred27_Java()) ) {s = 13;}
16621
16622                        else if ( (true) ) {s = 14;}
16623
16624
16625                        input.seek(index15_11);
16626                        if ( s>=0 ) return s;
16627                        break;
16628                    case 11 :
16629                        int LA15_12 = input.LA(1);
16630
16631
16632                        int index15_12 = input.index();
16633                        input.rewind();
16634                        s = -1;
16635                        if ( (synpred27_Java()) ) {s = 13;}
16636
16637                        else if ( (true) ) {s = 14;}
16638
16639
16640                        input.seek(index15_12);
16641                        if ( s>=0 ) return s;
16642                        break;
16643            }
16644            if (state.backtracking>0) {state.failed=true; return -1;}
16645            NoViableAltException nvae =
16646                new NoViableAltException(getDescription(), 15, _s, input);
16647            error(nvae);
16648            throw nvae;
16649        }
16650    }
16651    static final String DFA31_eotS =
16652        "\17\uffff";
16653    static final String DFA31_eofS =
16654        "\17\uffff";
16655    static final String DFA31_minS =
16656        "\1\34\14\0\2\uffff";
16657    static final String DFA31_maxS =
16658        "\1\162\14\0\2\uffff";
16659    static final String DFA31_acceptS =
16660        "\15\uffff\1\1\1\2";
16661    static final String DFA31_specialS =
16662        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\2\uffff}>";
16663    static final String[] DFA31_transitionS = {
16664            "\1\6\20\uffff\1\7\11\uffff\1\15\1\uffff\1\10\2\uffff\1\4\1\3"+
16665            "\1\2\2\uffff\1\5\1\14\2\uffff\1\11\3\uffff\1\12\2\uffff\1\13"+
16666            "\45\uffff\1\1",
16667            "\1\uffff",
16668            "\1\uffff",
16669            "\1\uffff",
16670            "\1\uffff",
16671            "\1\uffff",
16672            "\1\uffff",
16673            "\1\uffff",
16674            "\1\uffff",
16675            "\1\uffff",
16676            "\1\uffff",
16677            "\1\uffff",
16678            "\1\uffff",
16679            "",
16680            ""
16681    };
16682
16683    static final short[] DFA31_eot = DFA.unpackEncodedString(DFA31_eotS);
16684    static final short[] DFA31_eof = DFA.unpackEncodedString(DFA31_eofS);
16685    static final char[] DFA31_min = DFA.unpackEncodedStringToUnsignedChars(DFA31_minS);
16686    static final char[] DFA31_max = DFA.unpackEncodedStringToUnsignedChars(DFA31_maxS);
16687    static final short[] DFA31_accept = DFA.unpackEncodedString(DFA31_acceptS);
16688    static final short[] DFA31_special = DFA.unpackEncodedString(DFA31_specialS);
16689    static final short[][] DFA31_transition;
16690
16691    static {
16692        int numStates = DFA31_transitionS.length;
16693        DFA31_transition = new short[numStates][];
16694        for (int i=0; i<numStates; i++) {
16695            DFA31_transition[i] = DFA.unpackEncodedString(DFA31_transitionS[i]);
16696        }
16697    }
16698
16699    class DFA31 extends DFA {
16700
16701        public DFA31(BaseRecognizer recognizer) {
16702            this.recognizer = recognizer;
16703            this.decisionNumber = 31;
16704            this.eot = DFA31_eot;
16705            this.eof = DFA31_eof;
16706            this.min = DFA31_min;
16707            this.max = DFA31_max;
16708            this.accept = DFA31_accept;
16709            this.special = DFA31_special;
16710            this.transition = DFA31_transition;
16711        }
16712        public String getDescription() {
16713            return "460:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );";
16714        }
16715        public void error(NoViableAltException nvae) {
16716            dbg.recognitionException(nvae);
16717        }
16718        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
16719            TokenStream input = (TokenStream)_input;
16720		int _s = s;
16721            switch ( s ) {
16722                    case 0 :
16723                        int LA31_1 = input.LA(1);
16724
16725
16726                        int index31_1 = input.index();
16727                        input.rewind();
16728                        s = -1;
16729                        if ( (synpred43_Java()) ) {s = 13;}
16730
16731                        else if ( (true) ) {s = 14;}
16732
16733
16734                        input.seek(index31_1);
16735                        if ( s>=0 ) return s;
16736                        break;
16737                    case 1 :
16738                        int LA31_2 = input.LA(1);
16739
16740
16741                        int index31_2 = input.index();
16742                        input.rewind();
16743                        s = -1;
16744                        if ( (synpred43_Java()) ) {s = 13;}
16745
16746                        else if ( (true) ) {s = 14;}
16747
16748
16749                        input.seek(index31_2);
16750                        if ( s>=0 ) return s;
16751                        break;
16752                    case 2 :
16753                        int LA31_3 = input.LA(1);
16754
16755
16756                        int index31_3 = input.index();
16757                        input.rewind();
16758                        s = -1;
16759                        if ( (synpred43_Java()) ) {s = 13;}
16760
16761                        else if ( (true) ) {s = 14;}
16762
16763
16764                        input.seek(index31_3);
16765                        if ( s>=0 ) return s;
16766                        break;
16767                    case 3 :
16768                        int LA31_4 = input.LA(1);
16769
16770
16771                        int index31_4 = input.index();
16772                        input.rewind();
16773                        s = -1;
16774                        if ( (synpred43_Java()) ) {s = 13;}
16775
16776                        else if ( (true) ) {s = 14;}
16777
16778
16779                        input.seek(index31_4);
16780                        if ( s>=0 ) return s;
16781                        break;
16782                    case 4 :
16783                        int LA31_5 = input.LA(1);
16784
16785
16786                        int index31_5 = input.index();
16787                        input.rewind();
16788                        s = -1;
16789                        if ( (synpred43_Java()) ) {s = 13;}
16790
16791                        else if ( (true) ) {s = 14;}
16792
16793
16794                        input.seek(index31_5);
16795                        if ( s>=0 ) return s;
16796                        break;
16797                    case 5 :
16798                        int LA31_6 = input.LA(1);
16799
16800
16801                        int index31_6 = input.index();
16802                        input.rewind();
16803                        s = -1;
16804                        if ( (synpred43_Java()) ) {s = 13;}
16805
16806                        else if ( (true) ) {s = 14;}
16807
16808
16809                        input.seek(index31_6);
16810                        if ( s>=0 ) return s;
16811                        break;
16812                    case 6 :
16813                        int LA31_7 = input.LA(1);
16814
16815
16816                        int index31_7 = input.index();
16817                        input.rewind();
16818                        s = -1;
16819                        if ( (synpred43_Java()) ) {s = 13;}
16820
16821                        else if ( (true) ) {s = 14;}
16822
16823
16824                        input.seek(index31_7);
16825                        if ( s>=0 ) return s;
16826                        break;
16827                    case 7 :
16828                        int LA31_8 = input.LA(1);
16829
16830
16831                        int index31_8 = input.index();
16832                        input.rewind();
16833                        s = -1;
16834                        if ( (synpred43_Java()) ) {s = 13;}
16835
16836                        else if ( (true) ) {s = 14;}
16837
16838
16839                        input.seek(index31_8);
16840                        if ( s>=0 ) return s;
16841                        break;
16842                    case 8 :
16843                        int LA31_9 = input.LA(1);
16844
16845
16846                        int index31_9 = input.index();
16847                        input.rewind();
16848                        s = -1;
16849                        if ( (synpred43_Java()) ) {s = 13;}
16850
16851                        else if ( (true) ) {s = 14;}
16852
16853
16854                        input.seek(index31_9);
16855                        if ( s>=0 ) return s;
16856                        break;
16857                    case 9 :
16858                        int LA31_10 = input.LA(1);
16859
16860
16861                        int index31_10 = input.index();
16862                        input.rewind();
16863                        s = -1;
16864                        if ( (synpred43_Java()) ) {s = 13;}
16865
16866                        else if ( (true) ) {s = 14;}
16867
16868
16869                        input.seek(index31_10);
16870                        if ( s>=0 ) return s;
16871                        break;
16872                    case 10 :
16873                        int LA31_11 = input.LA(1);
16874
16875
16876                        int index31_11 = input.index();
16877                        input.rewind();
16878                        s = -1;
16879                        if ( (synpred43_Java()) ) {s = 13;}
16880
16881                        else if ( (true) ) {s = 14;}
16882
16883
16884                        input.seek(index31_11);
16885                        if ( s>=0 ) return s;
16886                        break;
16887                    case 11 :
16888                        int LA31_12 = input.LA(1);
16889
16890
16891                        int index31_12 = input.index();
16892                        input.rewind();
16893                        s = -1;
16894                        if ( (synpred43_Java()) ) {s = 13;}
16895
16896                        else if ( (true) ) {s = 14;}
16897
16898
16899                        input.seek(index31_12);
16900                        if ( s>=0 ) return s;
16901                        break;
16902            }
16903            if (state.backtracking>0) {state.failed=true; return -1;}
16904            NoViableAltException nvae =
16905                new NoViableAltException(getDescription(), 31, _s, input);
16906            error(nvae);
16907            throw nvae;
16908        }
16909    }
16910    static final String DFA39_eotS =
16911        "\25\uffff";
16912    static final String DFA39_eofS =
16913        "\25\uffff";
16914    static final String DFA39_minS =
16915        "\1\4\16\0\6\uffff";
16916    static final String DFA39_maxS =
16917        "\1\165\16\0\6\uffff";
16918    static final String DFA39_acceptS =
16919        "\17\uffff\1\2\1\uffff\1\3\1\uffff\1\4\1\1";
16920    static final String DFA39_specialS =
16921        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
16922        "\1\15\6\uffff}>";
16923    static final String[] DFA39_transitionS = {
16924            "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+
16925            "\21\4\uffff\1\16\1\uffff\1\21\1\uffff\1\7\1\uffff\1\16\6\uffff"+
16926            "\1\16\1\23\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+
16927            "\14\2\uffff\1\11\3\uffff\1\12\1\uffff\1\17\1\13\45\uffff\1\1"+
16928            "\2\uffff\1\17",
16929            "\1\uffff",
16930            "\1\uffff",
16931            "\1\uffff",
16932            "\1\uffff",
16933            "\1\uffff",
16934            "\1\uffff",
16935            "\1\uffff",
16936            "\1\uffff",
16937            "\1\uffff",
16938            "\1\uffff",
16939            "\1\uffff",
16940            "\1\uffff",
16941            "\1\uffff",
16942            "\1\uffff",
16943            "",
16944            "",
16945            "",
16946            "",
16947            "",
16948            ""
16949    };
16950
16951    static final short[] DFA39_eot = DFA.unpackEncodedString(DFA39_eotS);
16952    static final short[] DFA39_eof = DFA.unpackEncodedString(DFA39_eofS);
16953    static final char[] DFA39_min = DFA.unpackEncodedStringToUnsignedChars(DFA39_minS);
16954    static final char[] DFA39_max = DFA.unpackEncodedStringToUnsignedChars(DFA39_maxS);
16955    static final short[] DFA39_accept = DFA.unpackEncodedString(DFA39_acceptS);
16956    static final short[] DFA39_special = DFA.unpackEncodedString(DFA39_specialS);
16957    static final short[][] DFA39_transition;
16958
16959    static {
16960        int numStates = DFA39_transitionS.length;
16961        DFA39_transition = new short[numStates][];
16962        for (int i=0; i<numStates; i++) {
16963            DFA39_transition[i] = DFA.unpackEncodedString(DFA39_transitionS[i]);
16964        }
16965    }
16966
16967    class DFA39 extends DFA {
16968
16969        public DFA39(BaseRecognizer recognizer) {
16970            this.recognizer = recognizer;
16971            this.decisionNumber = 39;
16972            this.eot = DFA39_eot;
16973            this.eof = DFA39_eof;
16974            this.min = DFA39_min;
16975            this.max = DFA39_max;
16976            this.accept = DFA39_accept;
16977            this.special = DFA39_special;
16978            this.transition = DFA39_transition;
16979        }
16980        public String getDescription() {
16981            return "502:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );";
16982        }
16983        public void error(NoViableAltException nvae) {
16984            dbg.recognitionException(nvae);
16985        }
16986        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
16987            TokenStream input = (TokenStream)_input;
16988		int _s = s;
16989            switch ( s ) {
16990                    case 0 :
16991                        int LA39_1 = input.LA(1);
16992
16993
16994                        int index39_1 = input.index();
16995                        input.rewind();
16996                        s = -1;
16997                        if ( (synpred52_Java()) ) {s = 20;}
16998
16999                        else if ( (synpred53_Java()) ) {s = 15;}
17000
17001                        else if ( (synpred54_Java()) ) {s = 17;}
17002
17003                        else if ( (true) ) {s = 19;}
17004
17005
17006                        input.seek(index39_1);
17007                        if ( s>=0 ) return s;
17008                        break;
17009                    case 1 :
17010                        int LA39_2 = input.LA(1);
17011
17012
17013                        int index39_2 = input.index();
17014                        input.rewind();
17015                        s = -1;
17016                        if ( (synpred52_Java()) ) {s = 20;}
17017
17018                        else if ( (synpred53_Java()) ) {s = 15;}
17019
17020                        else if ( (synpred54_Java()) ) {s = 17;}
17021
17022                        else if ( (true) ) {s = 19;}
17023
17024
17025                        input.seek(index39_2);
17026                        if ( s>=0 ) return s;
17027                        break;
17028                    case 2 :
17029                        int LA39_3 = input.LA(1);
17030
17031
17032                        int index39_3 = input.index();
17033                        input.rewind();
17034                        s = -1;
17035                        if ( (synpred52_Java()) ) {s = 20;}
17036
17037                        else if ( (synpred53_Java()) ) {s = 15;}
17038
17039                        else if ( (synpred54_Java()) ) {s = 17;}
17040
17041                        else if ( (true) ) {s = 19;}
17042
17043
17044                        input.seek(index39_3);
17045                        if ( s>=0 ) return s;
17046                        break;
17047                    case 3 :
17048                        int LA39_4 = input.LA(1);
17049
17050
17051                        int index39_4 = input.index();
17052                        input.rewind();
17053                        s = -1;
17054                        if ( (synpred52_Java()) ) {s = 20;}
17055
17056                        else if ( (synpred53_Java()) ) {s = 15;}
17057
17058                        else if ( (synpred54_Java()) ) {s = 17;}
17059
17060                        else if ( (true) ) {s = 19;}
17061
17062
17063                        input.seek(index39_4);
17064                        if ( s>=0 ) return s;
17065                        break;
17066                    case 4 :
17067                        int LA39_5 = input.LA(1);
17068
17069
17070                        int index39_5 = input.index();
17071                        input.rewind();
17072                        s = -1;
17073                        if ( (synpred52_Java()) ) {s = 20;}
17074
17075                        else if ( (synpred53_Java()) ) {s = 15;}
17076
17077                        else if ( (synpred54_Java()) ) {s = 17;}
17078
17079                        else if ( (true) ) {s = 19;}
17080
17081
17082                        input.seek(index39_5);
17083                        if ( s>=0 ) return s;
17084                        break;
17085                    case 5 :
17086                        int LA39_6 = input.LA(1);
17087
17088
17089                        int index39_6 = input.index();
17090                        input.rewind();
17091                        s = -1;
17092                        if ( (synpred52_Java()) ) {s = 20;}
17093
17094                        else if ( (synpred53_Java()) ) {s = 15;}
17095
17096                        else if ( (synpred54_Java()) ) {s = 17;}
17097
17098                        else if ( (true) ) {s = 19;}
17099
17100
17101                        input.seek(index39_6);
17102                        if ( s>=0 ) return s;
17103                        break;
17104                    case 6 :
17105                        int LA39_7 = input.LA(1);
17106
17107
17108                        int index39_7 = input.index();
17109                        input.rewind();
17110                        s = -1;
17111                        if ( (synpred52_Java()) ) {s = 20;}
17112
17113                        else if ( (synpred53_Java()) ) {s = 15;}
17114
17115                        else if ( (synpred54_Java()) ) {s = 17;}
17116
17117                        else if ( (true) ) {s = 19;}
17118
17119
17120                        input.seek(index39_7);
17121                        if ( s>=0 ) return s;
17122                        break;
17123                    case 7 :
17124                        int LA39_8 = input.LA(1);
17125
17126
17127                        int index39_8 = input.index();
17128                        input.rewind();
17129                        s = -1;
17130                        if ( (synpred52_Java()) ) {s = 20;}
17131
17132                        else if ( (synpred53_Java()) ) {s = 15;}
17133
17134                        else if ( (synpred54_Java()) ) {s = 17;}
17135
17136                        else if ( (true) ) {s = 19;}
17137
17138
17139                        input.seek(index39_8);
17140                        if ( s>=0 ) return s;
17141                        break;
17142                    case 8 :
17143                        int LA39_9 = input.LA(1);
17144
17145
17146                        int index39_9 = input.index();
17147                        input.rewind();
17148                        s = -1;
17149                        if ( (synpred52_Java()) ) {s = 20;}
17150
17151                        else if ( (synpred53_Java()) ) {s = 15;}
17152
17153                        else if ( (synpred54_Java()) ) {s = 17;}
17154
17155                        else if ( (true) ) {s = 19;}
17156
17157
17158                        input.seek(index39_9);
17159                        if ( s>=0 ) return s;
17160                        break;
17161                    case 9 :
17162                        int LA39_10 = input.LA(1);
17163
17164
17165                        int index39_10 = input.index();
17166                        input.rewind();
17167                        s = -1;
17168                        if ( (synpred52_Java()) ) {s = 20;}
17169
17170                        else if ( (synpred53_Java()) ) {s = 15;}
17171
17172                        else if ( (synpred54_Java()) ) {s = 17;}
17173
17174                        else if ( (true) ) {s = 19;}
17175
17176
17177                        input.seek(index39_10);
17178                        if ( s>=0 ) return s;
17179                        break;
17180                    case 10 :
17181                        int LA39_11 = input.LA(1);
17182
17183
17184                        int index39_11 = input.index();
17185                        input.rewind();
17186                        s = -1;
17187                        if ( (synpred52_Java()) ) {s = 20;}
17188
17189                        else if ( (synpred53_Java()) ) {s = 15;}
17190
17191                        else if ( (synpred54_Java()) ) {s = 17;}
17192
17193                        else if ( (true) ) {s = 19;}
17194
17195
17196                        input.seek(index39_11);
17197                        if ( s>=0 ) return s;
17198                        break;
17199                    case 11 :
17200                        int LA39_12 = input.LA(1);
17201
17202
17203                        int index39_12 = input.index();
17204                        input.rewind();
17205                        s = -1;
17206                        if ( (synpred52_Java()) ) {s = 20;}
17207
17208                        else if ( (synpred53_Java()) ) {s = 15;}
17209
17210                        else if ( (synpred54_Java()) ) {s = 17;}
17211
17212                        else if ( (true) ) {s = 19;}
17213
17214
17215                        input.seek(index39_12);
17216                        if ( s>=0 ) return s;
17217                        break;
17218                    case 12 :
17219                        int LA39_13 = input.LA(1);
17220
17221
17222                        int index39_13 = input.index();
17223                        input.rewind();
17224                        s = -1;
17225                        if ( (synpred52_Java()) ) {s = 20;}
17226
17227                        else if ( (synpred53_Java()) ) {s = 15;}
17228
17229
17230                        input.seek(index39_13);
17231                        if ( s>=0 ) return s;
17232                        break;
17233                    case 13 :
17234                        int LA39_14 = input.LA(1);
17235
17236
17237                        int index39_14 = input.index();
17238                        input.rewind();
17239                        s = -1;
17240                        if ( (synpred52_Java()) ) {s = 20;}
17241
17242                        else if ( (synpred53_Java()) ) {s = 15;}
17243
17244
17245                        input.seek(index39_14);
17246                        if ( s>=0 ) return s;
17247                        break;
17248            }
17249            if (state.backtracking>0) {state.failed=true; return -1;}
17250            NoViableAltException nvae =
17251                new NoViableAltException(getDescription(), 39, _s, input);
17252            error(nvae);
17253            throw nvae;
17254        }
17255    }
17256    static final String DFA49_eotS =
17257        "\22\uffff";
17258    static final String DFA49_eofS =
17259        "\22\uffff";
17260    static final String DFA49_minS =
17261        "\1\4\16\0\3\uffff";
17262    static final String DFA49_maxS =
17263        "\1\165\16\0\3\uffff";
17264    static final String DFA49_acceptS =
17265        "\17\uffff\1\2\1\uffff\1\1";
17266    static final String DFA49_specialS =
17267        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
17268        "\1\15\3\uffff}>";
17269    static final String[] DFA49_transitionS = {
17270            "\1\16\27\uffff\1\6\1\uffff\1\17\1\uffff\1\17\2\uffff\1\17\5"+
17271            "\uffff\1\17\3\uffff\1\7\1\uffff\1\17\6\uffff\1\17\1\uffff\1"+
17272            "\17\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\17\1\5\1\14\2\uffff\1"+
17273            "\11\3\uffff\1\12\1\uffff\1\17\1\13\45\uffff\1\1\2\uffff\1\15",
17274            "\1\uffff",
17275            "\1\uffff",
17276            "\1\uffff",
17277            "\1\uffff",
17278            "\1\uffff",
17279            "\1\uffff",
17280            "\1\uffff",
17281            "\1\uffff",
17282            "\1\uffff",
17283            "\1\uffff",
17284            "\1\uffff",
17285            "\1\uffff",
17286            "\1\uffff",
17287            "\1\uffff",
17288            "",
17289            "",
17290            ""
17291    };
17292
17293    static final short[] DFA49_eot = DFA.unpackEncodedString(DFA49_eotS);
17294    static final short[] DFA49_eof = DFA.unpackEncodedString(DFA49_eofS);
17295    static final char[] DFA49_min = DFA.unpackEncodedStringToUnsignedChars(DFA49_minS);
17296    static final char[] DFA49_max = DFA.unpackEncodedStringToUnsignedChars(DFA49_maxS);
17297    static final short[] DFA49_accept = DFA.unpackEncodedString(DFA49_acceptS);
17298    static final short[] DFA49_special = DFA.unpackEncodedString(DFA49_specialS);
17299    static final short[][] DFA49_transition;
17300
17301    static {
17302        int numStates = DFA49_transitionS.length;
17303        DFA49_transition = new short[numStates][];
17304        for (int i=0; i<numStates; i++) {
17305            DFA49_transition[i] = DFA.unpackEncodedString(DFA49_transitionS[i]);
17306        }
17307    }
17308
17309    class DFA49 extends DFA {
17310
17311        public DFA49(BaseRecognizer recognizer) {
17312            this.recognizer = recognizer;
17313            this.decisionNumber = 49;
17314            this.eot = DFA49_eot;
17315            this.eof = DFA49_eof;
17316            this.min = DFA49_min;
17317            this.max = DFA49_max;
17318            this.accept = DFA49_accept;
17319            this.special = DFA49_special;
17320            this.transition = DFA49_transition;
17321        }
17322        public String getDescription() {
17323            return "510:1: methodDeclaration : ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' | modifiers ( typeParameters )? ( type | 'void' ) IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) );";
17324        }
17325        public void error(NoViableAltException nvae) {
17326            dbg.recognitionException(nvae);
17327        }
17328        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
17329            TokenStream input = (TokenStream)_input;
17330		int _s = s;
17331            switch ( s ) {
17332                    case 0 :
17333                        int LA49_1 = input.LA(1);
17334
17335
17336                        int index49_1 = input.index();
17337                        input.rewind();
17338                        s = -1;
17339                        if ( (synpred59_Java()) ) {s = 17;}
17340
17341                        else if ( (true) ) {s = 15;}
17342
17343
17344                        input.seek(index49_1);
17345                        if ( s>=0 ) return s;
17346                        break;
17347                    case 1 :
17348                        int LA49_2 = input.LA(1);
17349
17350
17351                        int index49_2 = input.index();
17352                        input.rewind();
17353                        s = -1;
17354                        if ( (synpred59_Java()) ) {s = 17;}
17355
17356                        else if ( (true) ) {s = 15;}
17357
17358
17359                        input.seek(index49_2);
17360                        if ( s>=0 ) return s;
17361                        break;
17362                    case 2 :
17363                        int LA49_3 = input.LA(1);
17364
17365
17366                        int index49_3 = input.index();
17367                        input.rewind();
17368                        s = -1;
17369                        if ( (synpred59_Java()) ) {s = 17;}
17370
17371                        else if ( (true) ) {s = 15;}
17372
17373
17374                        input.seek(index49_3);
17375                        if ( s>=0 ) return s;
17376                        break;
17377                    case 3 :
17378                        int LA49_4 = input.LA(1);
17379
17380
17381                        int index49_4 = input.index();
17382                        input.rewind();
17383                        s = -1;
17384                        if ( (synpred59_Java()) ) {s = 17;}
17385
17386                        else if ( (true) ) {s = 15;}
17387
17388
17389                        input.seek(index49_4);
17390                        if ( s>=0 ) return s;
17391                        break;
17392                    case 4 :
17393                        int LA49_5 = input.LA(1);
17394
17395
17396                        int index49_5 = input.index();
17397                        input.rewind();
17398                        s = -1;
17399                        if ( (synpred59_Java()) ) {s = 17;}
17400
17401                        else if ( (true) ) {s = 15;}
17402
17403
17404                        input.seek(index49_5);
17405                        if ( s>=0 ) return s;
17406                        break;
17407                    case 5 :
17408                        int LA49_6 = input.LA(1);
17409
17410
17411                        int index49_6 = input.index();
17412                        input.rewind();
17413                        s = -1;
17414                        if ( (synpred59_Java()) ) {s = 17;}
17415
17416                        else if ( (true) ) {s = 15;}
17417
17418
17419                        input.seek(index49_6);
17420                        if ( s>=0 ) return s;
17421                        break;
17422                    case 6 :
17423                        int LA49_7 = input.LA(1);
17424
17425
17426                        int index49_7 = input.index();
17427                        input.rewind();
17428                        s = -1;
17429                        if ( (synpred59_Java()) ) {s = 17;}
17430
17431                        else if ( (true) ) {s = 15;}
17432
17433
17434                        input.seek(index49_7);
17435                        if ( s>=0 ) return s;
17436                        break;
17437                    case 7 :
17438                        int LA49_8 = input.LA(1);
17439
17440
17441                        int index49_8 = input.index();
17442                        input.rewind();
17443                        s = -1;
17444                        if ( (synpred59_Java()) ) {s = 17;}
17445
17446                        else if ( (true) ) {s = 15;}
17447
17448
17449                        input.seek(index49_8);
17450                        if ( s>=0 ) return s;
17451                        break;
17452                    case 8 :
17453                        int LA49_9 = input.LA(1);
17454
17455
17456                        int index49_9 = input.index();
17457                        input.rewind();
17458                        s = -1;
17459                        if ( (synpred59_Java()) ) {s = 17;}
17460
17461                        else if ( (true) ) {s = 15;}
17462
17463
17464                        input.seek(index49_9);
17465                        if ( s>=0 ) return s;
17466                        break;
17467                    case 9 :
17468                        int LA49_10 = input.LA(1);
17469
17470
17471                        int index49_10 = input.index();
17472                        input.rewind();
17473                        s = -1;
17474                        if ( (synpred59_Java()) ) {s = 17;}
17475
17476                        else if ( (true) ) {s = 15;}
17477
17478
17479                        input.seek(index49_10);
17480                        if ( s>=0 ) return s;
17481                        break;
17482                    case 10 :
17483                        int LA49_11 = input.LA(1);
17484
17485
17486                        int index49_11 = input.index();
17487                        input.rewind();
17488                        s = -1;
17489                        if ( (synpred59_Java()) ) {s = 17;}
17490
17491                        else if ( (true) ) {s = 15;}
17492
17493
17494                        input.seek(index49_11);
17495                        if ( s>=0 ) return s;
17496                        break;
17497                    case 11 :
17498                        int LA49_12 = input.LA(1);
17499
17500
17501                        int index49_12 = input.index();
17502                        input.rewind();
17503                        s = -1;
17504                        if ( (synpred59_Java()) ) {s = 17;}
17505
17506                        else if ( (true) ) {s = 15;}
17507
17508
17509                        input.seek(index49_12);
17510                        if ( s>=0 ) return s;
17511                        break;
17512                    case 12 :
17513                        int LA49_13 = input.LA(1);
17514
17515
17516                        int index49_13 = input.index();
17517                        input.rewind();
17518                        s = -1;
17519                        if ( (synpred59_Java()) ) {s = 17;}
17520
17521                        else if ( (true) ) {s = 15;}
17522
17523
17524                        input.seek(index49_13);
17525                        if ( s>=0 ) return s;
17526                        break;
17527                    case 13 :
17528                        int LA49_14 = input.LA(1);
17529
17530
17531                        int index49_14 = input.index();
17532                        input.rewind();
17533                        s = -1;
17534                        if ( (synpred59_Java()) ) {s = 17;}
17535
17536                        else if ( (true) ) {s = 15;}
17537
17538
17539                        input.seek(index49_14);
17540                        if ( s>=0 ) return s;
17541                        break;
17542            }
17543            if (state.backtracking>0) {state.failed=true; return -1;}
17544            NoViableAltException nvae =
17545                new NoViableAltException(getDescription(), 49, _s, input);
17546            error(nvae);
17547            throw nvae;
17548        }
17549    }
17550    static final String DFA42_eotS =
17551        "\55\uffff";
17552    static final String DFA42_eofS =
17553        "\55\uffff";
17554    static final String DFA42_minS =
17555        "\1\4\1\uffff\10\0\43\uffff";
17556    static final String DFA42_maxS =
17557        "\1\165\1\uffff\10\0\43\uffff";
17558    static final String DFA42_acceptS =
17559        "\1\uffff\1\1\10\uffff\1\2\42\uffff";
17560    static final String DFA42_specialS =
17561        "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\43\uffff}>";
17562    static final String[] DFA42_transitionS = {
17563            "\1\5\11\6\16\uffff\2\12\1\10\1\12\1\10\2\uffff\1\10\1\12\1\uffff"+
17564            "\1\12\1\uffff\1\12\1\10\1\uffff\1\12\1\uffff\1\12\1\uffff\1"+
17565            "\10\1\12\1\uffff\1\12\3\uffff\1\10\1\12\1\10\1\12\1\7\1\uffff"+
17566            "\4\12\1\10\2\12\1\4\2\12\1\2\1\12\1\uffff\2\12\1\11\2\12\1\3"+
17567            "\1\uffff\2\12\2\uffff\1\12\4\uffff\2\12\5\uffff\4\12\16\uffff"+
17568            "\1\12\2\uffff\1\1",
17569            "",
17570            "\1\uffff",
17571            "\1\uffff",
17572            "\1\uffff",
17573            "\1\uffff",
17574            "\1\uffff",
17575            "\1\uffff",
17576            "\1\uffff",
17577            "\1\uffff",
17578            "",
17579            "",
17580            "",
17581            "",
17582            "",
17583            "",
17584            "",
17585            "",
17586            "",
17587            "",
17588            "",
17589            "",
17590            "",
17591            "",
17592            "",
17593            "",
17594            "",
17595            "",
17596            "",
17597            "",
17598            "",
17599            "",
17600            "",
17601            "",
17602            "",
17603            "",
17604            "",
17605            "",
17606            "",
17607            "",
17608            "",
17609            "",
17610            "",
17611            "",
17612            ""
17613    };
17614
17615    static final short[] DFA42_eot = DFA.unpackEncodedString(DFA42_eotS);
17616    static final short[] DFA42_eof = DFA.unpackEncodedString(DFA42_eofS);
17617    static final char[] DFA42_min = DFA.unpackEncodedStringToUnsignedChars(DFA42_minS);
17618    static final char[] DFA42_max = DFA.unpackEncodedStringToUnsignedChars(DFA42_maxS);
17619    static final short[] DFA42_accept = DFA.unpackEncodedString(DFA42_acceptS);
17620    static final short[] DFA42_special = DFA.unpackEncodedString(DFA42_specialS);
17621    static final short[][] DFA42_transition;
17622
17623    static {
17624        int numStates = DFA42_transitionS.length;
17625        DFA42_transition = new short[numStates][];
17626        for (int i=0; i<numStates; i++) {
17627            DFA42_transition[i] = DFA.unpackEncodedString(DFA42_transitionS[i]);
17628        }
17629    }
17630
17631    class DFA42 extends DFA {
17632
17633        public DFA42(BaseRecognizer recognizer) {
17634            this.recognizer = recognizer;
17635            this.decisionNumber = 42;
17636            this.eot = DFA42_eot;
17637            this.eof = DFA42_eof;
17638            this.min = DFA42_min;
17639            this.max = DFA42_max;
17640            this.accept = DFA42_accept;
17641            this.special = DFA42_special;
17642            this.transition = DFA42_transition;
17643        }
17644        public String getDescription() {
17645            return "521:9: ( explicitConstructorInvocation )?";
17646        }
17647        public void error(NoViableAltException nvae) {
17648            dbg.recognitionException(nvae);
17649        }
17650        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
17651            TokenStream input = (TokenStream)_input;
17652		int _s = s;
17653            switch ( s ) {
17654                    case 0 :
17655                        int LA42_2 = input.LA(1);
17656
17657
17658                        int index42_2 = input.index();
17659                        input.rewind();
17660                        s = -1;
17661                        if ( (synpred57_Java()) ) {s = 1;}
17662
17663                        else if ( (true) ) {s = 10;}
17664
17665
17666                        input.seek(index42_2);
17667                        if ( s>=0 ) return s;
17668                        break;
17669                    case 1 :
17670                        int LA42_3 = input.LA(1);
17671
17672
17673                        int index42_3 = input.index();
17674                        input.rewind();
17675                        s = -1;
17676                        if ( (synpred57_Java()) ) {s = 1;}
17677
17678                        else if ( (true) ) {s = 10;}
17679
17680
17681                        input.seek(index42_3);
17682                        if ( s>=0 ) return s;
17683                        break;
17684                    case 2 :
17685                        int LA42_4 = input.LA(1);
17686
17687
17688                        int index42_4 = input.index();
17689                        input.rewind();
17690                        s = -1;
17691                        if ( (synpred57_Java()) ) {s = 1;}
17692
17693                        else if ( (true) ) {s = 10;}
17694
17695
17696                        input.seek(index42_4);
17697                        if ( s>=0 ) return s;
17698                        break;
17699                    case 3 :
17700                        int LA42_5 = input.LA(1);
17701
17702
17703                        int index42_5 = input.index();
17704                        input.rewind();
17705                        s = -1;
17706                        if ( (synpred57_Java()) ) {s = 1;}
17707
17708                        else if ( (true) ) {s = 10;}
17709
17710
17711                        input.seek(index42_5);
17712                        if ( s>=0 ) return s;
17713                        break;
17714                    case 4 :
17715                        int LA42_6 = input.LA(1);
17716
17717
17718                        int index42_6 = input.index();
17719                        input.rewind();
17720                        s = -1;
17721                        if ( (synpred57_Java()) ) {s = 1;}
17722
17723                        else if ( (true) ) {s = 10;}
17724
17725
17726                        input.seek(index42_6);
17727                        if ( s>=0 ) return s;
17728                        break;
17729                    case 5 :
17730                        int LA42_7 = input.LA(1);
17731
17732
17733                        int index42_7 = input.index();
17734                        input.rewind();
17735                        s = -1;
17736                        if ( (synpred57_Java()) ) {s = 1;}
17737
17738                        else if ( (true) ) {s = 10;}
17739
17740
17741                        input.seek(index42_7);
17742                        if ( s>=0 ) return s;
17743                        break;
17744                    case 6 :
17745                        int LA42_8 = input.LA(1);
17746
17747
17748                        int index42_8 = input.index();
17749                        input.rewind();
17750                        s = -1;
17751                        if ( (synpred57_Java()) ) {s = 1;}
17752
17753                        else if ( (true) ) {s = 10;}
17754
17755
17756                        input.seek(index42_8);
17757                        if ( s>=0 ) return s;
17758                        break;
17759                    case 7 :
17760                        int LA42_9 = input.LA(1);
17761
17762
17763                        int index42_9 = input.index();
17764                        input.rewind();
17765                        s = -1;
17766                        if ( (synpred57_Java()) ) {s = 1;}
17767
17768                        else if ( (true) ) {s = 10;}
17769
17770
17771                        input.seek(index42_9);
17772                        if ( s>=0 ) return s;
17773                        break;
17774            }
17775            if (state.backtracking>0) {state.failed=true; return -1;}
17776            NoViableAltException nvae =
17777                new NoViableAltException(getDescription(), 42, _s, input);
17778            error(nvae);
17779            throw nvae;
17780        }
17781    }
17782    static final String DFA53_eotS =
17783        "\26\uffff";
17784    static final String DFA53_eofS =
17785        "\26\uffff";
17786    static final String DFA53_minS =
17787        "\1\4\16\0\7\uffff";
17788    static final String DFA53_maxS =
17789        "\1\165\16\0\7\uffff";
17790    static final String DFA53_acceptS =
17791        "\17\uffff\1\2\1\uffff\1\3\1\4\1\uffff\1\5\1\1";
17792    static final String DFA53_specialS =
17793        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
17794        "\1\15\7\uffff}>";
17795    static final String[] DFA53_transitionS = {
17796            "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+
17797            "\22\4\uffff\1\16\1\uffff\1\22\1\uffff\1\7\1\uffff\1\16\6\uffff"+
17798            "\1\16\1\21\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+
17799            "\14\2\uffff\1\11\3\uffff\1\12\1\uffff\1\17\1\13\7\uffff\1\24"+
17800            "\35\uffff\1\1\2\uffff\1\17",
17801            "\1\uffff",
17802            "\1\uffff",
17803            "\1\uffff",
17804            "\1\uffff",
17805            "\1\uffff",
17806            "\1\uffff",
17807            "\1\uffff",
17808            "\1\uffff",
17809            "\1\uffff",
17810            "\1\uffff",
17811            "\1\uffff",
17812            "\1\uffff",
17813            "\1\uffff",
17814            "\1\uffff",
17815            "",
17816            "",
17817            "",
17818            "",
17819            "",
17820            "",
17821            ""
17822    };
17823
17824    static final short[] DFA53_eot = DFA.unpackEncodedString(DFA53_eotS);
17825    static final short[] DFA53_eof = DFA.unpackEncodedString(DFA53_eofS);
17826    static final char[] DFA53_min = DFA.unpackEncodedStringToUnsignedChars(DFA53_minS);
17827    static final char[] DFA53_max = DFA.unpackEncodedStringToUnsignedChars(DFA53_maxS);
17828    static final short[] DFA53_accept = DFA.unpackEncodedString(DFA53_acceptS);
17829    static final short[] DFA53_special = DFA.unpackEncodedString(DFA53_specialS);
17830    static final short[][] DFA53_transition;
17831
17832    static {
17833        int numStates = DFA53_transitionS.length;
17834        DFA53_transition = new short[numStates][];
17835        for (int i=0; i<numStates; i++) {
17836            DFA53_transition[i] = DFA.unpackEncodedString(DFA53_transitionS[i]);
17837        }
17838    }
17839
17840    class DFA53 extends DFA {
17841
17842        public DFA53(BaseRecognizer recognizer) {
17843            this.recognizer = recognizer;
17844            this.decisionNumber = 53;
17845            this.eot = DFA53_eot;
17846            this.eof = DFA53_eof;
17847            this.min = DFA53_min;
17848            this.max = DFA53_max;
17849            this.accept = DFA53_accept;
17850            this.special = DFA53_special;
17851            this.transition = DFA53_transition;
17852        }
17853        public String getDescription() {
17854            return "562:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' );";
17855        }
17856        public void error(NoViableAltException nvae) {
17857            dbg.recognitionException(nvae);
17858        }
17859        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
17860            TokenStream input = (TokenStream)_input;
17861		int _s = s;
17862            switch ( s ) {
17863                    case 0 :
17864                        int LA53_1 = input.LA(1);
17865
17866
17867                        int index53_1 = input.index();
17868                        input.rewind();
17869                        s = -1;
17870                        if ( (synpred68_Java()) ) {s = 21;}
17871
17872                        else if ( (synpred69_Java()) ) {s = 15;}
17873
17874                        else if ( (synpred70_Java()) ) {s = 17;}
17875
17876                        else if ( (synpred71_Java()) ) {s = 18;}
17877
17878
17879                        input.seek(index53_1);
17880                        if ( s>=0 ) return s;
17881                        break;
17882                    case 1 :
17883                        int LA53_2 = input.LA(1);
17884
17885
17886                        int index53_2 = input.index();
17887                        input.rewind();
17888                        s = -1;
17889                        if ( (synpred68_Java()) ) {s = 21;}
17890
17891                        else if ( (synpred69_Java()) ) {s = 15;}
17892
17893                        else if ( (synpred70_Java()) ) {s = 17;}
17894
17895                        else if ( (synpred71_Java()) ) {s = 18;}
17896
17897
17898                        input.seek(index53_2);
17899                        if ( s>=0 ) return s;
17900                        break;
17901                    case 2 :
17902                        int LA53_3 = input.LA(1);
17903
17904
17905                        int index53_3 = input.index();
17906                        input.rewind();
17907                        s = -1;
17908                        if ( (synpred68_Java()) ) {s = 21;}
17909
17910                        else if ( (synpred69_Java()) ) {s = 15;}
17911
17912                        else if ( (synpred70_Java()) ) {s = 17;}
17913
17914                        else if ( (synpred71_Java()) ) {s = 18;}
17915
17916
17917                        input.seek(index53_3);
17918                        if ( s>=0 ) return s;
17919                        break;
17920                    case 3 :
17921                        int LA53_4 = input.LA(1);
17922
17923
17924                        int index53_4 = input.index();
17925                        input.rewind();
17926                        s = -1;
17927                        if ( (synpred68_Java()) ) {s = 21;}
17928
17929                        else if ( (synpred69_Java()) ) {s = 15;}
17930
17931                        else if ( (synpred70_Java()) ) {s = 17;}
17932
17933                        else if ( (synpred71_Java()) ) {s = 18;}
17934
17935
17936                        input.seek(index53_4);
17937                        if ( s>=0 ) return s;
17938                        break;
17939                    case 4 :
17940                        int LA53_5 = input.LA(1);
17941
17942
17943                        int index53_5 = input.index();
17944                        input.rewind();
17945                        s = -1;
17946                        if ( (synpred68_Java()) ) {s = 21;}
17947
17948                        else if ( (synpred69_Java()) ) {s = 15;}
17949
17950                        else if ( (synpred70_Java()) ) {s = 17;}
17951
17952                        else if ( (synpred71_Java()) ) {s = 18;}
17953
17954
17955                        input.seek(index53_5);
17956                        if ( s>=0 ) return s;
17957                        break;
17958                    case 5 :
17959                        int LA53_6 = input.LA(1);
17960
17961
17962                        int index53_6 = input.index();
17963                        input.rewind();
17964                        s = -1;
17965                        if ( (synpred68_Java()) ) {s = 21;}
17966
17967                        else if ( (synpred69_Java()) ) {s = 15;}
17968
17969                        else if ( (synpred70_Java()) ) {s = 17;}
17970
17971                        else if ( (synpred71_Java()) ) {s = 18;}
17972
17973
17974                        input.seek(index53_6);
17975                        if ( s>=0 ) return s;
17976                        break;
17977                    case 6 :
17978                        int LA53_7 = input.LA(1);
17979
17980
17981                        int index53_7 = input.index();
17982                        input.rewind();
17983                        s = -1;
17984                        if ( (synpred68_Java()) ) {s = 21;}
17985
17986                        else if ( (synpred69_Java()) ) {s = 15;}
17987
17988                        else if ( (synpred70_Java()) ) {s = 17;}
17989
17990                        else if ( (synpred71_Java()) ) {s = 18;}
17991
17992
17993                        input.seek(index53_7);
17994                        if ( s>=0 ) return s;
17995                        break;
17996                    case 7 :
17997                        int LA53_8 = input.LA(1);
17998
17999
18000                        int index53_8 = input.index();
18001                        input.rewind();
18002                        s = -1;
18003                        if ( (synpred68_Java()) ) {s = 21;}
18004
18005                        else if ( (synpred69_Java()) ) {s = 15;}
18006
18007                        else if ( (synpred70_Java()) ) {s = 17;}
18008
18009                        else if ( (synpred71_Java()) ) {s = 18;}
18010
18011
18012                        input.seek(index53_8);
18013                        if ( s>=0 ) return s;
18014                        break;
18015                    case 8 :
18016                        int LA53_9 = input.LA(1);
18017
18018
18019                        int index53_9 = input.index();
18020                        input.rewind();
18021                        s = -1;
18022                        if ( (synpred68_Java()) ) {s = 21;}
18023
18024                        else if ( (synpred69_Java()) ) {s = 15;}
18025
18026                        else if ( (synpred70_Java()) ) {s = 17;}
18027
18028                        else if ( (synpred71_Java()) ) {s = 18;}
18029
18030
18031                        input.seek(index53_9);
18032                        if ( s>=0 ) return s;
18033                        break;
18034                    case 9 :
18035                        int LA53_10 = input.LA(1);
18036
18037
18038                        int index53_10 = input.index();
18039                        input.rewind();
18040                        s = -1;
18041                        if ( (synpred68_Java()) ) {s = 21;}
18042
18043                        else if ( (synpred69_Java()) ) {s = 15;}
18044
18045                        else if ( (synpred70_Java()) ) {s = 17;}
18046
18047                        else if ( (synpred71_Java()) ) {s = 18;}
18048
18049
18050                        input.seek(index53_10);
18051                        if ( s>=0 ) return s;
18052                        break;
18053                    case 10 :
18054                        int LA53_11 = input.LA(1);
18055
18056
18057                        int index53_11 = input.index();
18058                        input.rewind();
18059                        s = -1;
18060                        if ( (synpred68_Java()) ) {s = 21;}
18061
18062                        else if ( (synpred69_Java()) ) {s = 15;}
18063
18064                        else if ( (synpred70_Java()) ) {s = 17;}
18065
18066                        else if ( (synpred71_Java()) ) {s = 18;}
18067
18068
18069                        input.seek(index53_11);
18070                        if ( s>=0 ) return s;
18071                        break;
18072                    case 11 :
18073                        int LA53_12 = input.LA(1);
18074
18075
18076                        int index53_12 = input.index();
18077                        input.rewind();
18078                        s = -1;
18079                        if ( (synpred68_Java()) ) {s = 21;}
18080
18081                        else if ( (synpred69_Java()) ) {s = 15;}
18082
18083                        else if ( (synpred70_Java()) ) {s = 17;}
18084
18085                        else if ( (synpred71_Java()) ) {s = 18;}
18086
18087
18088                        input.seek(index53_12);
18089                        if ( s>=0 ) return s;
18090                        break;
18091                    case 12 :
18092                        int LA53_13 = input.LA(1);
18093
18094
18095                        int index53_13 = input.index();
18096                        input.rewind();
18097                        s = -1;
18098                        if ( (synpred68_Java()) ) {s = 21;}
18099
18100                        else if ( (synpred69_Java()) ) {s = 15;}
18101
18102
18103                        input.seek(index53_13);
18104                        if ( s>=0 ) return s;
18105                        break;
18106                    case 13 :
18107                        int LA53_14 = input.LA(1);
18108
18109
18110                        int index53_14 = input.index();
18111                        input.rewind();
18112                        s = -1;
18113                        if ( (synpred68_Java()) ) {s = 21;}
18114
18115                        else if ( (synpred69_Java()) ) {s = 15;}
18116
18117
18118                        input.seek(index53_14);
18119                        if ( s>=0 ) return s;
18120                        break;
18121            }
18122            if (state.backtracking>0) {state.failed=true; return -1;}
18123            NoViableAltException nvae =
18124                new NoViableAltException(getDescription(), 53, _s, input);
18125            error(nvae);
18126            throw nvae;
18127        }
18128    }
18129    static final String DFA76_eotS =
18130        "\12\uffff";
18131    static final String DFA76_eofS =
18132        "\12\uffff";
18133    static final String DFA76_minS =
18134        "\1\4\1\uffff\1\0\1\uffff\1\0\5\uffff";
18135    static final String DFA76_maxS =
18136        "\1\165\1\uffff\1\0\1\uffff\1\0\5\uffff";
18137    static final String DFA76_acceptS =
18138        "\1\uffff\1\1\1\uffff\1\2\6\uffff";
18139    static final String DFA76_specialS =
18140        "\2\uffff\1\0\1\uffff\1\1\5\uffff}>";
18141    static final String[] DFA76_transitionS = {
18142            "\12\3\20\uffff\1\3\1\uffff\1\3\2\uffff\1\3\5\uffff\1\3\5\uffff"+
18143            "\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\5\uffff\1\3\2\uffff"+
18144            "\1\4\2\uffff\1\2\4\uffff\1\3\2\uffff\1\3\46\uffff\1\1",
18145            "",
18146            "\1\uffff",
18147            "",
18148            "\1\uffff",
18149            "",
18150            "",
18151            "",
18152            "",
18153            ""
18154    };
18155
18156    static final short[] DFA76_eot = DFA.unpackEncodedString(DFA76_eotS);
18157    static final short[] DFA76_eof = DFA.unpackEncodedString(DFA76_eofS);
18158    static final char[] DFA76_min = DFA.unpackEncodedStringToUnsignedChars(DFA76_minS);
18159    static final char[] DFA76_max = DFA.unpackEncodedStringToUnsignedChars(DFA76_maxS);
18160    static final short[] DFA76_accept = DFA.unpackEncodedString(DFA76_acceptS);
18161    static final short[] DFA76_special = DFA.unpackEncodedString(DFA76_specialS);
18162    static final short[][] DFA76_transition;
18163
18164    static {
18165        int numStates = DFA76_transitionS.length;
18166        DFA76_transition = new short[numStates][];
18167        for (int i=0; i<numStates; i++) {
18168            DFA76_transition[i] = DFA.unpackEncodedString(DFA76_transitionS[i]);
18169        }
18170    }
18171
18172    class DFA76 extends DFA {
18173
18174        public DFA76(BaseRecognizer recognizer) {
18175            this.recognizer = recognizer;
18176            this.decisionNumber = 76;
18177            this.eot = DFA76_eot;
18178            this.eof = DFA76_eof;
18179            this.min = DFA76_min;
18180            this.max = DFA76_max;
18181            this.accept = DFA76_accept;
18182            this.special = DFA76_special;
18183            this.transition = DFA76_transition;
18184        }
18185        public String getDescription() {
18186            return "688:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' );";
18187        }
18188        public void error(NoViableAltException nvae) {
18189            dbg.recognitionException(nvae);
18190        }
18191        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
18192            TokenStream input = (TokenStream)_input;
18193		int _s = s;
18194            switch ( s ) {
18195                    case 0 :
18196                        int LA76_2 = input.LA(1);
18197
18198
18199                        int index76_2 = input.index();
18200                        input.rewind();
18201                        s = -1;
18202                        if ( (synpred103_Java()) ) {s = 1;}
18203
18204                        else if ( (true) ) {s = 3;}
18205
18206
18207                        input.seek(index76_2);
18208                        if ( s>=0 ) return s;
18209                        break;
18210                    case 1 :
18211                        int LA76_4 = input.LA(1);
18212
18213
18214                        int index76_4 = input.index();
18215                        input.rewind();
18216                        s = -1;
18217                        if ( (synpred103_Java()) ) {s = 1;}
18218
18219                        else if ( (true) ) {s = 3;}
18220
18221
18222                        input.seek(index76_4);
18223                        if ( s>=0 ) return s;
18224                        break;
18225            }
18226            if (state.backtracking>0) {state.failed=true; return -1;}
18227            NoViableAltException nvae =
18228                new NoViableAltException(getDescription(), 76, _s, input);
18229            error(nvae);
18230            throw nvae;
18231        }
18232    }
18233    static final String DFA87_eotS =
18234        "\26\uffff";
18235    static final String DFA87_eofS =
18236        "\26\uffff";
18237    static final String DFA87_minS =
18238        "\1\4\16\0\7\uffff";
18239    static final String DFA87_maxS =
18240        "\1\162\16\0\7\uffff";
18241    static final String DFA87_acceptS =
18242        "\17\uffff\1\3\1\4\1\5\1\7\1\1\1\2\1\6";
18243    static final String DFA87_specialS =
18244        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14"+
18245        "\1\15\7\uffff}>";
18246    static final String[] DFA87_transitionS = {
18247            "\1\15\27\uffff\1\6\1\uffff\1\16\1\uffff\1\16\2\uffff\1\16\1"+
18248            "\17\4\uffff\1\16\1\uffff\1\21\1\uffff\1\7\1\uffff\1\16\6\uffff"+
18249            "\1\16\1\20\1\16\1\10\2\uffff\1\4\1\3\1\2\1\uffff\1\16\1\5\1"+
18250            "\14\2\uffff\1\11\3\uffff\1\12\2\uffff\1\13\7\uffff\1\22\35\uffff"+
18251            "\1\1",
18252            "\1\uffff",
18253            "\1\uffff",
18254            "\1\uffff",
18255            "\1\uffff",
18256            "\1\uffff",
18257            "\1\uffff",
18258            "\1\uffff",
18259            "\1\uffff",
18260            "\1\uffff",
18261            "\1\uffff",
18262            "\1\uffff",
18263            "\1\uffff",
18264            "\1\uffff",
18265            "\1\uffff",
18266            "",
18267            "",
18268            "",
18269            "",
18270            "",
18271            "",
18272            ""
18273    };
18274
18275    static final short[] DFA87_eot = DFA.unpackEncodedString(DFA87_eotS);
18276    static final short[] DFA87_eof = DFA.unpackEncodedString(DFA87_eofS);
18277    static final char[] DFA87_min = DFA.unpackEncodedStringToUnsignedChars(DFA87_minS);
18278    static final char[] DFA87_max = DFA.unpackEncodedStringToUnsignedChars(DFA87_maxS);
18279    static final short[] DFA87_accept = DFA.unpackEncodedString(DFA87_acceptS);
18280    static final short[] DFA87_special = DFA.unpackEncodedString(DFA87_specialS);
18281    static final short[][] DFA87_transition;
18282
18283    static {
18284        int numStates = DFA87_transitionS.length;
18285        DFA87_transition = new short[numStates][];
18286        for (int i=0; i<numStates; i++) {
18287            DFA87_transition[i] = DFA.unpackEncodedString(DFA87_transitionS[i]);
18288        }
18289    }
18290
18291    class DFA87 extends DFA {
18292
18293        public DFA87(BaseRecognizer recognizer) {
18294            this.recognizer = recognizer;
18295            this.decisionNumber = 87;
18296            this.eot = DFA87_eot;
18297            this.eof = DFA87_eof;
18298            this.min = DFA87_min;
18299            this.max = DFA87_max;
18300            this.accept = DFA87_accept;
18301            this.special = DFA87_special;
18302            this.transition = DFA87_transition;
18303        }
18304        public String getDescription() {
18305            return "772:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' );";
18306        }
18307        public void error(NoViableAltException nvae) {
18308            dbg.recognitionException(nvae);
18309        }
18310        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
18311            TokenStream input = (TokenStream)_input;
18312		int _s = s;
18313            switch ( s ) {
18314                    case 0 :
18315                        int LA87_1 = input.LA(1);
18316
18317
18318                        int index87_1 = input.index();
18319                        input.rewind();
18320                        s = -1;
18321                        if ( (synpred117_Java()) ) {s = 19;}
18322
18323                        else if ( (synpred118_Java()) ) {s = 20;}
18324
18325                        else if ( (synpred119_Java()) ) {s = 15;}
18326
18327                        else if ( (synpred120_Java()) ) {s = 16;}
18328
18329                        else if ( (synpred121_Java()) ) {s = 17;}
18330
18331                        else if ( (synpred122_Java()) ) {s = 21;}
18332
18333
18334                        input.seek(index87_1);
18335                        if ( s>=0 ) return s;
18336                        break;
18337                    case 1 :
18338                        int LA87_2 = input.LA(1);
18339
18340
18341                        int index87_2 = input.index();
18342                        input.rewind();
18343                        s = -1;
18344                        if ( (synpred117_Java()) ) {s = 19;}
18345
18346                        else if ( (synpred118_Java()) ) {s = 20;}
18347
18348                        else if ( (synpred119_Java()) ) {s = 15;}
18349
18350                        else if ( (synpred120_Java()) ) {s = 16;}
18351
18352                        else if ( (synpred121_Java()) ) {s = 17;}
18353
18354                        else if ( (synpred122_Java()) ) {s = 21;}
18355
18356
18357                        input.seek(index87_2);
18358                        if ( s>=0 ) return s;
18359                        break;
18360                    case 2 :
18361                        int LA87_3 = input.LA(1);
18362
18363
18364                        int index87_3 = input.index();
18365                        input.rewind();
18366                        s = -1;
18367                        if ( (synpred117_Java()) ) {s = 19;}
18368
18369                        else if ( (synpred118_Java()) ) {s = 20;}
18370
18371                        else if ( (synpred119_Java()) ) {s = 15;}
18372
18373                        else if ( (synpred120_Java()) ) {s = 16;}
18374
18375                        else if ( (synpred121_Java()) ) {s = 17;}
18376
18377                        else if ( (synpred122_Java()) ) {s = 21;}
18378
18379
18380                        input.seek(index87_3);
18381                        if ( s>=0 ) return s;
18382                        break;
18383                    case 3 :
18384                        int LA87_4 = input.LA(1);
18385
18386
18387                        int index87_4 = input.index();
18388                        input.rewind();
18389                        s = -1;
18390                        if ( (synpred117_Java()) ) {s = 19;}
18391
18392                        else if ( (synpred118_Java()) ) {s = 20;}
18393
18394                        else if ( (synpred119_Java()) ) {s = 15;}
18395
18396                        else if ( (synpred120_Java()) ) {s = 16;}
18397
18398                        else if ( (synpred121_Java()) ) {s = 17;}
18399
18400                        else if ( (synpred122_Java()) ) {s = 21;}
18401
18402
18403                        input.seek(index87_4);
18404                        if ( s>=0 ) return s;
18405                        break;
18406                    case 4 :
18407                        int LA87_5 = input.LA(1);
18408
18409
18410                        int index87_5 = input.index();
18411                        input.rewind();
18412                        s = -1;
18413                        if ( (synpred117_Java()) ) {s = 19;}
18414
18415                        else if ( (synpred118_Java()) ) {s = 20;}
18416
18417                        else if ( (synpred119_Java()) ) {s = 15;}
18418
18419                        else if ( (synpred120_Java()) ) {s = 16;}
18420
18421                        else if ( (synpred121_Java()) ) {s = 17;}
18422
18423                        else if ( (synpred122_Java()) ) {s = 21;}
18424
18425
18426                        input.seek(index87_5);
18427                        if ( s>=0 ) return s;
18428                        break;
18429                    case 5 :
18430                        int LA87_6 = input.LA(1);
18431
18432
18433                        int index87_6 = input.index();
18434                        input.rewind();
18435                        s = -1;
18436                        if ( (synpred117_Java()) ) {s = 19;}
18437
18438                        else if ( (synpred118_Java()) ) {s = 20;}
18439
18440                        else if ( (synpred119_Java()) ) {s = 15;}
18441
18442                        else if ( (synpred120_Java()) ) {s = 16;}
18443
18444                        else if ( (synpred121_Java()) ) {s = 17;}
18445
18446                        else if ( (synpred122_Java()) ) {s = 21;}
18447
18448
18449                        input.seek(index87_6);
18450                        if ( s>=0 ) return s;
18451                        break;
18452                    case 6 :
18453                        int LA87_7 = input.LA(1);
18454
18455
18456                        int index87_7 = input.index();
18457                        input.rewind();
18458                        s = -1;
18459                        if ( (synpred117_Java()) ) {s = 19;}
18460
18461                        else if ( (synpred118_Java()) ) {s = 20;}
18462
18463                        else if ( (synpred119_Java()) ) {s = 15;}
18464
18465                        else if ( (synpred120_Java()) ) {s = 16;}
18466
18467                        else if ( (synpred121_Java()) ) {s = 17;}
18468
18469                        else if ( (synpred122_Java()) ) {s = 21;}
18470
18471
18472                        input.seek(index87_7);
18473                        if ( s>=0 ) return s;
18474                        break;
18475                    case 7 :
18476                        int LA87_8 = input.LA(1);
18477
18478
18479                        int index87_8 = input.index();
18480                        input.rewind();
18481                        s = -1;
18482                        if ( (synpred117_Java()) ) {s = 19;}
18483
18484                        else if ( (synpred118_Java()) ) {s = 20;}
18485
18486                        else if ( (synpred119_Java()) ) {s = 15;}
18487
18488                        else if ( (synpred120_Java()) ) {s = 16;}
18489
18490                        else if ( (synpred121_Java()) ) {s = 17;}
18491
18492                        else if ( (synpred122_Java()) ) {s = 21;}
18493
18494
18495                        input.seek(index87_8);
18496                        if ( s>=0 ) return s;
18497                        break;
18498                    case 8 :
18499                        int LA87_9 = input.LA(1);
18500
18501
18502                        int index87_9 = input.index();
18503                        input.rewind();
18504                        s = -1;
18505                        if ( (synpred117_Java()) ) {s = 19;}
18506
18507                        else if ( (synpred118_Java()) ) {s = 20;}
18508
18509                        else if ( (synpred119_Java()) ) {s = 15;}
18510
18511                        else if ( (synpred120_Java()) ) {s = 16;}
18512
18513                        else if ( (synpred121_Java()) ) {s = 17;}
18514
18515                        else if ( (synpred122_Java()) ) {s = 21;}
18516
18517
18518                        input.seek(index87_9);
18519                        if ( s>=0 ) return s;
18520                        break;
18521                    case 9 :
18522                        int LA87_10 = input.LA(1);
18523
18524
18525                        int index87_10 = input.index();
18526                        input.rewind();
18527                        s = -1;
18528                        if ( (synpred117_Java()) ) {s = 19;}
18529
18530                        else if ( (synpred118_Java()) ) {s = 20;}
18531
18532                        else if ( (synpred119_Java()) ) {s = 15;}
18533
18534                        else if ( (synpred120_Java()) ) {s = 16;}
18535
18536                        else if ( (synpred121_Java()) ) {s = 17;}
18537
18538                        else if ( (synpred122_Java()) ) {s = 21;}
18539
18540
18541                        input.seek(index87_10);
18542                        if ( s>=0 ) return s;
18543                        break;
18544                    case 10 :
18545                        int LA87_11 = input.LA(1);
18546
18547
18548                        int index87_11 = input.index();
18549                        input.rewind();
18550                        s = -1;
18551                        if ( (synpred117_Java()) ) {s = 19;}
18552
18553                        else if ( (synpred118_Java()) ) {s = 20;}
18554
18555                        else if ( (synpred119_Java()) ) {s = 15;}
18556
18557                        else if ( (synpred120_Java()) ) {s = 16;}
18558
18559                        else if ( (synpred121_Java()) ) {s = 17;}
18560
18561                        else if ( (synpred122_Java()) ) {s = 21;}
18562
18563
18564                        input.seek(index87_11);
18565                        if ( s>=0 ) return s;
18566                        break;
18567                    case 11 :
18568                        int LA87_12 = input.LA(1);
18569
18570
18571                        int index87_12 = input.index();
18572                        input.rewind();
18573                        s = -1;
18574                        if ( (synpred117_Java()) ) {s = 19;}
18575
18576                        else if ( (synpred118_Java()) ) {s = 20;}
18577
18578                        else if ( (synpred119_Java()) ) {s = 15;}
18579
18580                        else if ( (synpred120_Java()) ) {s = 16;}
18581
18582                        else if ( (synpred121_Java()) ) {s = 17;}
18583
18584                        else if ( (synpred122_Java()) ) {s = 21;}
18585
18586
18587                        input.seek(index87_12);
18588                        if ( s>=0 ) return s;
18589                        break;
18590                    case 12 :
18591                        int LA87_13 = input.LA(1);
18592
18593
18594                        int index87_13 = input.index();
18595                        input.rewind();
18596                        s = -1;
18597                        if ( (synpred117_Java()) ) {s = 19;}
18598
18599                        else if ( (synpred118_Java()) ) {s = 20;}
18600
18601
18602                        input.seek(index87_13);
18603                        if ( s>=0 ) return s;
18604                        break;
18605                    case 13 :
18606                        int LA87_14 = input.LA(1);
18607
18608
18609                        int index87_14 = input.index();
18610                        input.rewind();
18611                        s = -1;
18612                        if ( (synpred117_Java()) ) {s = 19;}
18613
18614                        else if ( (synpred118_Java()) ) {s = 20;}
18615
18616
18617                        input.seek(index87_14);
18618                        if ( s>=0 ) return s;
18619                        break;
18620            }
18621            if (state.backtracking>0) {state.failed=true; return -1;}
18622            NoViableAltException nvae =
18623                new NoViableAltException(getDescription(), 87, _s, input);
18624            error(nvae);
18625            throw nvae;
18626        }
18627    }
18628    static final String DFA90_eotS =
18629        "\54\uffff";
18630    static final String DFA90_eofS =
18631        "\54\uffff";
18632    static final String DFA90_minS =
18633        "\1\4\4\0\6\uffff\1\0\40\uffff";
18634    static final String DFA90_maxS =
18635        "\1\162\4\0\6\uffff\1\0\40\uffff";
18636    static final String DFA90_acceptS =
18637        "\5\uffff\1\2\14\uffff\1\3\30\uffff\1\1";
18638    static final String DFA90_specialS =
18639        "\1\uffff\1\0\1\1\1\2\1\3\6\uffff\1\4\40\uffff}>";
18640    static final String[] DFA90_transitionS = {
18641            "\1\3\11\22\16\uffff\1\5\1\22\1\4\1\22\1\4\2\uffff\1\4\1\5\1"+
18642            "\uffff\1\22\1\uffff\1\22\1\4\1\uffff\1\5\1\uffff\1\1\1\uffff"+
18643            "\1\4\1\22\1\uffff\1\22\3\uffff\1\4\1\5\1\4\1\5\1\22\1\uffff"+
18644            "\3\5\1\22\1\4\2\5\2\22\1\13\2\22\1\uffff\1\5\2\22\1\5\2\22\1"+
18645            "\uffff\1\22\3\uffff\1\22\4\uffff\2\22\5\uffff\4\22\16\uffff"+
18646            "\1\2",
18647            "\1\uffff",
18648            "\1\uffff",
18649            "\1\uffff",
18650            "\1\uffff",
18651            "",
18652            "",
18653            "",
18654            "",
18655            "",
18656            "",
18657            "\1\uffff",
18658            "",
18659            "",
18660            "",
18661            "",
18662            "",
18663            "",
18664            "",
18665            "",
18666            "",
18667            "",
18668            "",
18669            "",
18670            "",
18671            "",
18672            "",
18673            "",
18674            "",
18675            "",
18676            "",
18677            "",
18678            "",
18679            "",
18680            "",
18681            "",
18682            "",
18683            "",
18684            "",
18685            "",
18686            "",
18687            "",
18688            "",
18689            ""
18690    };
18691
18692    static final short[] DFA90_eot = DFA.unpackEncodedString(DFA90_eotS);
18693    static final short[] DFA90_eof = DFA.unpackEncodedString(DFA90_eofS);
18694    static final char[] DFA90_min = DFA.unpackEncodedStringToUnsignedChars(DFA90_minS);
18695    static final char[] DFA90_max = DFA.unpackEncodedStringToUnsignedChars(DFA90_maxS);
18696    static final short[] DFA90_accept = DFA.unpackEncodedString(DFA90_acceptS);
18697    static final short[] DFA90_special = DFA.unpackEncodedString(DFA90_specialS);
18698    static final short[][] DFA90_transition;
18699
18700    static {
18701        int numStates = DFA90_transitionS.length;
18702        DFA90_transition = new short[numStates][];
18703        for (int i=0; i<numStates; i++) {
18704            DFA90_transition[i] = DFA.unpackEncodedString(DFA90_transitionS[i]);
18705        }
18706    }
18707
18708    class DFA90 extends DFA {
18709
18710        public DFA90(BaseRecognizer recognizer) {
18711            this.recognizer = recognizer;
18712            this.decisionNumber = 90;
18713            this.eot = DFA90_eot;
18714            this.eof = DFA90_eof;
18715            this.min = DFA90_min;
18716            this.max = DFA90_max;
18717            this.accept = DFA90_accept;
18718            this.special = DFA90_special;
18719            this.transition = DFA90_transition;
18720        }
18721        public String getDescription() {
18722            return "823:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );";
18723        }
18724        public void error(NoViableAltException nvae) {
18725            dbg.recognitionException(nvae);
18726        }
18727        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
18728            TokenStream input = (TokenStream)_input;
18729		int _s = s;
18730            switch ( s ) {
18731                    case 0 :
18732                        int LA90_1 = input.LA(1);
18733
18734
18735                        int index90_1 = input.index();
18736                        input.rewind();
18737                        s = -1;
18738                        if ( (synpred125_Java()) ) {s = 43;}
18739
18740                        else if ( (synpred126_Java()) ) {s = 5;}
18741
18742
18743                        input.seek(index90_1);
18744                        if ( s>=0 ) return s;
18745                        break;
18746                    case 1 :
18747                        int LA90_2 = input.LA(1);
18748
18749
18750                        int index90_2 = input.index();
18751                        input.rewind();
18752                        s = -1;
18753                        if ( (synpred125_Java()) ) {s = 43;}
18754
18755                        else if ( (synpred126_Java()) ) {s = 5;}
18756
18757
18758                        input.seek(index90_2);
18759                        if ( s>=0 ) return s;
18760                        break;
18761                    case 2 :
18762                        int LA90_3 = input.LA(1);
18763
18764
18765                        int index90_3 = input.index();
18766                        input.rewind();
18767                        s = -1;
18768                        if ( (synpred125_Java()) ) {s = 43;}
18769
18770                        else if ( (true) ) {s = 18;}
18771
18772
18773                        input.seek(index90_3);
18774                        if ( s>=0 ) return s;
18775                        break;
18776                    case 3 :
18777                        int LA90_4 = input.LA(1);
18778
18779
18780                        int index90_4 = input.index();
18781                        input.rewind();
18782                        s = -1;
18783                        if ( (synpred125_Java()) ) {s = 43;}
18784
18785                        else if ( (true) ) {s = 18;}
18786
18787
18788                        input.seek(index90_4);
18789                        if ( s>=0 ) return s;
18790                        break;
18791                    case 4 :
18792                        int LA90_11 = input.LA(1);
18793
18794
18795                        int index90_11 = input.index();
18796                        input.rewind();
18797                        s = -1;
18798                        if ( (synpred126_Java()) ) {s = 5;}
18799
18800                        else if ( (true) ) {s = 18;}
18801
18802
18803                        input.seek(index90_11);
18804                        if ( s>=0 ) return s;
18805                        break;
18806            }
18807            if (state.backtracking>0) {state.failed=true; return -1;}
18808            NoViableAltException nvae =
18809                new NoViableAltException(getDescription(), 90, _s, input);
18810            error(nvae);
18811            throw nvae;
18812        }
18813    }
18814    static final String DFA98_eotS =
18815        "\40\uffff";
18816    static final String DFA98_eofS =
18817        "\40\uffff";
18818    static final String DFA98_minS =
18819        "\1\4\1\uffff\1\0\23\uffff\1\0\11\uffff";
18820    static final String DFA98_maxS =
18821        "\1\143\1\uffff\1\0\23\uffff\1\0\11\uffff";
18822    static final String DFA98_acceptS =
18823        "\1\uffff\1\1\1\uffff\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"+
18824        "\15\1\16\1\17\15\uffff\1\21\1\2\1\3\1\20";
18825    static final String DFA98_specialS =
18826        "\2\uffff\1\0\23\uffff\1\1\11\uffff}>";
18827    static final String[] DFA98_transitionS = {
18828            "\1\26\11\16\17\uffff\1\2\1\16\1\14\1\16\2\uffff\1\16\2\uffff"+
18829            "\1\15\1\uffff\1\6\1\16\5\uffff\1\16\1\4\1\uffff\1\3\3\uffff"+
18830            "\1\16\1\uffff\1\16\1\uffff\1\16\4\uffff\1\12\1\16\2\uffff\1"+
18831            "\16\1\10\1\11\1\16\1\13\2\uffff\1\7\1\16\1\uffff\1\5\1\16\1"+
18832            "\uffff\1\1\3\uffff\1\34\4\uffff\2\16\5\uffff\4\16",
18833            "",
18834            "\1\uffff",
18835            "",
18836            "",
18837            "",
18838            "",
18839            "",
18840            "",
18841            "",
18842            "",
18843            "",
18844            "",
18845            "",
18846            "",
18847            "",
18848            "",
18849            "",
18850            "",
18851            "",
18852            "",
18853            "",
18854            "\1\uffff",
18855            "",
18856            "",
18857            "",
18858            "",
18859            "",
18860            "",
18861            "",
18862            "",
18863            ""
18864    };
18865
18866    static final short[] DFA98_eot = DFA.unpackEncodedString(DFA98_eotS);
18867    static final short[] DFA98_eof = DFA.unpackEncodedString(DFA98_eofS);
18868    static final char[] DFA98_min = DFA.unpackEncodedStringToUnsignedChars(DFA98_minS);
18869    static final char[] DFA98_max = DFA.unpackEncodedStringToUnsignedChars(DFA98_maxS);
18870    static final short[] DFA98_accept = DFA.unpackEncodedString(DFA98_acceptS);
18871    static final short[] DFA98_special = DFA.unpackEncodedString(DFA98_specialS);
18872    static final short[][] DFA98_transition;
18873
18874    static {
18875        int numStates = DFA98_transitionS.length;
18876        DFA98_transition = new short[numStates][];
18877        for (int i=0; i<numStates; i++) {
18878            DFA98_transition[i] = DFA.unpackEncodedString(DFA98_transitionS[i]);
18879        }
18880    }
18881
18882    class DFA98 extends DFA {
18883
18884        public DFA98(BaseRecognizer recognizer) {
18885            this.recognizer = recognizer;
18886            this.decisionNumber = 98;
18887            this.eot = DFA98_eot;
18888            this.eof = DFA98_eof;
18889            this.min = DFA98_min;
18890            this.max = DFA98_max;
18891            this.accept = DFA98_accept;
18892            this.special = DFA98_special;
18893            this.transition = DFA98_transition;
18894        }
18895        public String getDescription() {
18896            return "842:1: statement : ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' );";
18897        }
18898        public void error(NoViableAltException nvae) {
18899            dbg.recognitionException(nvae);
18900        }
18901        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
18902            TokenStream input = (TokenStream)_input;
18903		int _s = s;
18904            switch ( s ) {
18905                    case 0 :
18906                        int LA98_2 = input.LA(1);
18907
18908
18909                        int index98_2 = input.index();
18910                        input.rewind();
18911                        s = -1;
18912                        if ( (synpred130_Java()) ) {s = 29;}
18913
18914                        else if ( (synpred132_Java()) ) {s = 30;}
18915
18916
18917                        input.seek(index98_2);
18918                        if ( s>=0 ) return s;
18919                        break;
18920                    case 1 :
18921                        int LA98_22 = input.LA(1);
18922
18923
18924                        int index98_22 = input.index();
18925                        input.rewind();
18926                        s = -1;
18927                        if ( (synpred148_Java()) ) {s = 14;}
18928
18929                        else if ( (synpred149_Java()) ) {s = 31;}
18930
18931
18932                        input.seek(index98_22);
18933                        if ( s>=0 ) return s;
18934                        break;
18935            }
18936            if (state.backtracking>0) {state.failed=true; return -1;}
18937            NoViableAltException nvae =
18938                new NoViableAltException(getDescription(), 98, _s, input);
18939            error(nvae);
18940            throw nvae;
18941        }
18942    }
18943    static final String DFA109_eotS =
18944        "\21\uffff";
18945    static final String DFA109_eofS =
18946        "\21\uffff";
18947    static final String DFA109_minS =
18948        "\1\4\2\uffff\2\0\14\uffff";
18949    static final String DFA109_maxS =
18950        "\1\162\2\uffff\2\0\14\uffff";
18951    static final String DFA109_acceptS =
18952        "\1\uffff\1\1\3\uffff\1\2\13\uffff";
18953    static final String DFA109_specialS =
18954        "\3\uffff\1\0\1\1\14\uffff}>";
18955    static final String[] DFA109_transitionS = {
18956            "\1\3\11\5\20\uffff\1\4\1\uffff\1\4\2\uffff\1\4\5\uffff\1\4\3"+
18957            "\uffff\1\1\1\uffff\1\4\6\uffff\1\4\1\uffff\1\4\1\uffff\1\5\5"+
18958            "\uffff\1\4\2\uffff\1\5\2\uffff\1\5\4\uffff\1\5\2\uffff\1\5\12"+
18959            "\uffff\2\5\5\uffff\4\5\16\uffff\1\1",
18960            "",
18961            "",
18962            "\1\uffff",
18963            "\1\uffff",
18964            "",
18965            "",
18966            "",
18967            "",
18968            "",
18969            "",
18970            "",
18971            "",
18972            "",
18973            "",
18974            "",
18975            ""
18976    };
18977
18978    static final short[] DFA109_eot = DFA.unpackEncodedString(DFA109_eotS);
18979    static final short[] DFA109_eof = DFA.unpackEncodedString(DFA109_eofS);
18980    static final char[] DFA109_min = DFA.unpackEncodedStringToUnsignedChars(DFA109_minS);
18981    static final char[] DFA109_max = DFA.unpackEncodedStringToUnsignedChars(DFA109_maxS);
18982    static final short[] DFA109_accept = DFA.unpackEncodedString(DFA109_acceptS);
18983    static final short[] DFA109_special = DFA.unpackEncodedString(DFA109_specialS);
18984    static final short[][] DFA109_transition;
18985
18986    static {
18987        int numStates = DFA109_transitionS.length;
18988        DFA109_transition = new short[numStates][];
18989        for (int i=0; i<numStates; i++) {
18990            DFA109_transition[i] = DFA.unpackEncodedString(DFA109_transitionS[i]);
18991        }
18992    }
18993
18994    class DFA109 extends DFA {
18995
18996        public DFA109(BaseRecognizer recognizer) {
18997            this.recognizer = recognizer;
18998            this.decisionNumber = 109;
18999            this.eot = DFA109_eot;
19000            this.eof = DFA109_eof;
19001            this.min = DFA109_min;
19002            this.max = DFA109_max;
19003            this.accept = DFA109_accept;
19004            this.special = DFA109_special;
19005            this.transition = DFA109_transition;
19006        }
19007        public String getDescription() {
19008            return "928:1: forInit : ( localVariableDeclaration | expressionList );";
19009        }
19010        public void error(NoViableAltException nvae) {
19011            dbg.recognitionException(nvae);
19012        }
19013        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
19014            TokenStream input = (TokenStream)_input;
19015		int _s = s;
19016            switch ( s ) {
19017                    case 0 :
19018                        int LA109_3 = input.LA(1);
19019
19020
19021                        int index109_3 = input.index();
19022                        input.rewind();
19023                        s = -1;
19024                        if ( (synpred161_Java()) ) {s = 1;}
19025
19026                        else if ( (true) ) {s = 5;}
19027
19028
19029                        input.seek(index109_3);
19030                        if ( s>=0 ) return s;
19031                        break;
19032                    case 1 :
19033                        int LA109_4 = input.LA(1);
19034
19035
19036                        int index109_4 = input.index();
19037                        input.rewind();
19038                        s = -1;
19039                        if ( (synpred161_Java()) ) {s = 1;}
19040
19041                        else if ( (true) ) {s = 5;}
19042
19043
19044                        input.seek(index109_4);
19045                        if ( s>=0 ) return s;
19046                        break;
19047            }
19048            if (state.backtracking>0) {state.failed=true; return -1;}
19049            NoViableAltException nvae =
19050                new NoViableAltException(getDescription(), 109, _s, input);
19051            error(nvae);
19052            throw nvae;
19053        }
19054    }
19055    static final String DFA112_eotS =
19056        "\17\uffff";
19057    static final String DFA112_eofS =
19058        "\17\uffff";
19059    static final String DFA112_minS =
19060        "\1\130\12\uffff\1\164\1\130\2\uffff";
19061    static final String DFA112_maxS =
19062        "\1\165\12\uffff\2\164\2\uffff";
19063    static final String DFA112_acceptS =
19064        "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\2\uffff\1\13"+
19065        "\1\14";
19066    static final String DFA112_specialS =
19067        "\17\uffff}>";
19068    static final String[] DFA112_transitionS = {
19069            "\1\1\21\uffff\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\2\uffff\1\13"+
19070            "\1\12",
19071            "",
19072            "",
19073            "",
19074            "",
19075            "",
19076            "",
19077            "",
19078            "",
19079            "",
19080            "",
19081            "\1\14",
19082            "\1\16\33\uffff\1\15",
19083            "",
19084            ""
19085    };
19086
19087    static final short[] DFA112_eot = DFA.unpackEncodedString(DFA112_eotS);
19088    static final short[] DFA112_eof = DFA.unpackEncodedString(DFA112_eofS);
19089    static final char[] DFA112_min = DFA.unpackEncodedStringToUnsignedChars(DFA112_minS);
19090    static final char[] DFA112_max = DFA.unpackEncodedStringToUnsignedChars(DFA112_maxS);
19091    static final short[] DFA112_accept = DFA.unpackEncodedString(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
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        }
19116        public String getDescription() {
19117            return "951:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' );";
19118        }
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
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        }
19181        public String getDescription() {
19182            return "1080:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? );";
19183        }
19184        public void error(NoViableAltException nvae) {
19185            dbg.recognitionException(nvae);
19186        }
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
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        }
19292        public String getDescription() {
19293            return "1105:9: ( identifierSuffix )?";
19294        }
19295        public void error(NoViableAltException nvae) {
19296            dbg.recognitionException(nvae);
19297        }
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
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        }
19418        public String getDescription() {
19419            return "1110:9: ( identifierSuffix )?";
19420        }
19421        public void error(NoViableAltException nvae) {
19422            dbg.recognitionException(nvae);
19423        }
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
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        }
19524        public String getDescription() {
19525            return "1134:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator );";
19526        }
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
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        }
19609        public String getDescription() {
19610            return "()+ loopback of 1138:9: ( '[' expression ']' )+";
19611        }
19612        public void error(NoViableAltException nvae) {
19613            dbg.recognitionException(nvae);
19614        }
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
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        }
19720        public String getDescription() {
19721            return "()* loopback of 1176:9: ( '[' expression ']' )*";
19722        }
19723        public void error(NoViableAltException nvae) {
19724            dbg.recognitionException(nvae);
19725        }
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
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        }
19847        public String getDescription() {
19848            return "521:9: ( explicitConstructorInvocation )?";
19849        }
19850        public void error(NoViableAltException nvae) {
19851            dbg.recognitionException(nvae);
19852        }
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}