JavaParser/com/github/javaparser/GeneratedJavaParser.java

1	/* GeneratedJavaParser.java */
2	/* Generated by: ParserGeneratorCC: Do not edit this line. GeneratedJavaParser.java */
3	/*
4	* Copyright (C) 2007-2010 Júlio Vilmar Gesser.
5	* Copyright (C) 2011, 2013-2020 The JavaParser Team.
6	*
7	* This file is part of JavaParser.
8	*
9	* JavaParser can be used either under the terms of
10	* a) the GNU Lesser General Public License as published by
11	* the Free Software Foundation, either version 3 of the License, or
12	* (at your option) any later version.
13	* b) the terms of the Apache License
14	*
15	* You should have received a copy of both licenses in LICENCE.LGPL and
16	* LICENCE.APACHE. Please refer to those files for details.
17	*
18	* JavaParser is distributed in the hope that it will be useful,
19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	* GNU Lesser General Public License for more details.
22	*/
23	package com.github.javaparser;
24
25	import java.io.*;
26	import java.util.*;
27	import com.github.javaparser.ast.*;
28	import com.github.javaparser.ast.body.*;
29	import com.github.javaparser.ast.comments.*;
30	import com.github.javaparser.ast.modules.*;
31	import com.github.javaparser.ast.expr.*;
32	import com.github.javaparser.ast.stmt.*;
33	import com.github.javaparser.ast.type.*;
34	import com.github.javaparser.utils.*;
35	import static com.github.javaparser.JavaToken.INVALID;
36	import static com.github.javaparser.ast.Node.Parsedness.UNPARSABLE;
37	import static com.github.javaparser.utils.Utils.*;
38	import static com.github.javaparser.ast.NodeList.*;
39	import static com.github.javaparser.GeneratedJavaParser.*;
40	import static com.github.javaparser.Range.*;
41	import static com.github.javaparser.Position.*;
42	import static com.github.javaparser.ast.type.ArrayType.*;
43	import static com.github.javaparser.GeneratedJavaParserTokenManagerBase.*;
44	import static com.github.javaparser.ast.stmt.SwitchEntry.Type.*;
45
46	@Generated("JavaCC")
47	final class GeneratedJavaParser extends GeneratedJavaParserBase implements GeneratedJavaParserConstants {
48	/* Returns the JavaParser specific token type of the last matched token */
49	JavaToken token() {
50	return token.javaToken;
51	}
52
53	/* Changes the amount by which the horizontal position is increased when a tab character is encountered.
54	One by default.*/
55	void setTabSize(int size) {
56	jj_input_stream.setTabSize(size);
57	}
58
59	@Override
60	GeneratedJavaParserTokenManager getTokenSource() {
61	return token_source;
62	}
63
64	final public CompilationUnit CompilationUnit() throws ParseException {PackageDeclaration packageDeclaration = null;
65	NodeList<ImportDeclaration> imports = emptyNodeList();
66	ImportDeclaration in = null;
67	NodeList<TypeDeclaration<?>> types = emptyNodeList();
68	ModifierHolder modifier;
69	TypeDeclaration<?> tn = null;
70	ModuleDeclaration module = null;
71	try {
72	label_1:
73	while (true) {
74	if (jj_2_1(2)) {
75	} else {
76	break label_1;
77	}
78	jj_consume_token(SEMICOLON);
79	}
80	if (jj_2_2(2147483647)) {
81	packageDeclaration = PackageDeclaration();
82	} else {
83	;
84	}
85	label_2:
86	while (true) {
87	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
88	case ABSTRACT:
89	case CLASS:
90	case _DEFAULT:
91	case ENUM:
92	case FINAL:
93	case IMPORT:
94	case INTERFACE:
95	case NATIVE:
96	case PRIVATE:
97	case PROTECTED:
98	case PUBLIC:
99	case STATIC:
100	case STRICTFP:
101	case SYNCHRONIZED:
102	case TRANSIENT:
103	case VOLATILE:
104	case OPEN:
105	case MODULE:
106	case TRANSITIVE:
107	case SEMICOLON:
108	case AT:{
109	break;
110	}
111	default:
112	jj_la1[0] = jj_gen;
113	break label_2;
114	}
115	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
116	case IMPORT:{
117	in = ImportDeclaration();
118	imports = add(imports, in);
119	break;
120	}
121	case ABSTRACT:
122	case CLASS:
123	case _DEFAULT:
124	case ENUM:
125	case FINAL:
126	case INTERFACE:
127	case NATIVE:
128	case PRIVATE:
129	case PROTECTED:
130	case PUBLIC:
131	case STATIC:
132	case STRICTFP:
133	case SYNCHRONIZED:
134	case TRANSIENT:
135	case VOLATILE:
136	case OPEN:
137	case MODULE:
138	case TRANSITIVE:
139	case SEMICOLON:
140	case AT:{
141	modifier = Modifiers();
142	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
143	case CLASS:
144	case INTERFACE:{
145	tn = ClassOrInterfaceDeclaration(modifier);
146	types = add(types, tn);
147	break;
148	}
149	case ENUM:{
150	tn = EnumDeclaration(modifier);
151	types = add(types, tn);
152	break;
153	}
154	case AT:{
155	tn = AnnotationTypeDeclaration(modifier);
156	types = add(types, tn);
157	break;
158	}
159	case OPEN:
160	case MODULE:{
161	module = ModuleDeclaration(modifier);
162	break;
163	}
164	case SEMICOLON:{
165	jj_consume_token(SEMICOLON);
166	break;
167	}
168	default:
169	jj_la1[1] = jj_gen;
170	jj_consume_token(-1);
171	throw new ParseException();
172	}
173	break;
174	}
175	default:
176	jj_la1[2] = jj_gen;
177	jj_consume_token(-1);
178	throw new ParseException();
179	}
180	}
181	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
182	case 0:{
183	jj_consume_token(0);
184	break;
185	}
186	case CTRL_Z:{
187	jj_consume_token(CTRL_Z);
188	break;
189	}
190	default:
191	jj_la1[3] = jj_gen;
192	jj_consume_token(-1);
193	throw new ParseException();
194	}
195	{if ("" != null) return new CompilationUnit(range(token_source.getHomeToken(), token()), packageDeclaration, imports, types, module);}
196	} catch (ParseException e) {
197	recover(EOF, e);
198	final CompilationUnit compilationUnit = new CompilationUnit(range(token_source.getHomeToken(), token()), null, new NodeList<ImportDeclaration>(), new NodeList<TypeDeclaration<?>>(), null);
199	compilationUnit.setParsed(UNPARSABLE);
200	{if ("" != null) return compilationUnit;}
201	}
202	throw new IllegalStateException ("Missing return statement in function");
203	}
204
205	/**
206	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-7.html#jls-7.4.1
207	* <pre>{@code
208	* PackageDeclaration:
209	* {PackageModifier} package Identifier {. Identifier} ;
210	* PackageModifier:
211	* Annotation
212	* }</pre>
213	*/
214	final public PackageDeclaration PackageDeclaration() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
215	Name name;
216	JavaToken begin;
217	annotations = Annotations();
218	jj_consume_token(PACKAGE);
219	begin = token();
220	name = Name();
221	jj_consume_token(SEMICOLON);
222	{if ("" != null) return new PackageDeclaration(range(begin, token()), annotations, name);}
223	throw new IllegalStateException ("Missing return statement in function");
224	}
225
226	/**
227	* Import declaration types are not differentiated in the class hierarchy.
228	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-7.html#jls-7.5
229	* <pre>{@code
230	* ImportDeclaration:
231	* SingleTypeImportDeclaration
232	* TypeImportOnDemandDeclaration
233	* SingleStaticImportDeclaration
234	* StaticImportOnDemandDeclaration
235	* }</pre>
236	* Note that the JLS terminology "On Demand" and JavaParser terminology "Asterisk" are equivalent
237	* <pre>{@code
238	* SingleTypeImportDeclaration:
239	* import TypeName ;
240	* TypeImportOnDemandDeclaration:
241	* import PackageOrTypeName . * ;
242	* SingleStaticImportDeclaration:
243	* import static TypeName . Identifier ;
244	* StaticImportOnDemandDeclaration:
245	* import static TypeName . * ;
246	* }</pre>
247	*/
248	final public ImportDeclaration ImportDeclaration() throws ParseException {Name name;
249	boolean isStatic = false;
250	boolean isAsterisk = false;
251	JavaToken begin;
252	jj_consume_token(IMPORT);
253	begin = token();
254	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
255	case STATIC:{
256	jj_consume_token(STATIC);
257	isStatic = true;
258	break;
259	}
260	default:
261	jj_la1[4] = jj_gen;
262	;
263	}
264	name = Name();
265	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
266	case DOT:{
267	jj_consume_token(DOT);
268	jj_consume_token(STAR);
269	isAsterisk = true;
270	break;
271	}
272	default:
273	jj_la1[5] = jj_gen;
274	;
275	}
276	jj_consume_token(SEMICOLON);
277	{if ("" != null) return new ImportDeclaration(range(begin, token()), name, isStatic, isAsterisk);}
278	throw new IllegalStateException ("Missing return statement in function");
279	}
280
281	/*
282	* Modifiers. We match all modifiers in a single rule to reduce the chances of
283	* syntax errors for simple modifier mistakes. It will also enable us to give
284	* better error messages.
285	* Class Modifiers: https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.1.1
286	* <pre>{@code
287	* ClassModifier:
288	* (one of)
289	* Annotation public protected private
290	* abstract static final strictfp
291	* }</pre>
292	* Field Modifiers: https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.3.1
293	* <pre>{@code
294	* FieldModifier:
295	* (one of)
296	* Annotation public protected private
297	* static final transient volatile
298	* }</pre>
299	* Method Modifiers: https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.4.3
300	* <pre>{@code
301	* MethodModifier:
302	* (one of)
303	* Annotation public protected private
304	* abstract static final synchronized native strictfp
305	* }</pre>
306	* Constructor Modifiers: https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.8.3
307	* <pre>{@code
308	* ConstructorModifier:
309	* (one of)
310	* Annotation public protected private
311	* }</pre>
312	*/
313	final public ModifierHolder Modifiers() throws ParseException {JavaToken begin = INVALID;
314	NodeList<Modifier> modifiers = new NodeList<Modifier>();
315	NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
316	AnnotationExpr ann;
317	label_3:
318	while (true) {
319	if (jj_2_3(2)) {
320	} else {
321	break label_3;
322	}
323	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
324	case PUBLIC:{
325	jj_consume_token(PUBLIC);
326	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.PUBLIC)); begin = orIfInvalid(begin, token());
327	break;
328	}
329	case STATIC:{
330	jj_consume_token(STATIC);
331	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.STATIC)); begin = orIfInvalid(begin, token());
332	break;
333	}
334	case PROTECTED:{
335	jj_consume_token(PROTECTED);
336	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.PROTECTED)); begin = orIfInvalid(begin, token());
337	break;
338	}
339	case PRIVATE:{
340	jj_consume_token(PRIVATE);
341	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.PRIVATE)); begin = orIfInvalid(begin, token());
342	break;
343	}
344	case FINAL:{
345	jj_consume_token(FINAL);
346	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.FINAL)); begin = orIfInvalid(begin, token());
347	break;
348	}
349	case ABSTRACT:{
350	jj_consume_token(ABSTRACT);
351	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.ABSTRACT)); begin = orIfInvalid(begin, token());
352	break;
353	}
354	case SYNCHRONIZED:{
355	jj_consume_token(SYNCHRONIZED);
356	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.SYNCHRONIZED)); begin = orIfInvalid(begin, token());
357	break;
358	}
359	case NATIVE:{
360	jj_consume_token(NATIVE);
361	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.NATIVE)); begin = orIfInvalid(begin, token());
362	break;
363	}
364	case TRANSIENT:{
365	jj_consume_token(TRANSIENT);
366	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.TRANSIENT)); begin = orIfInvalid(begin, token());
367	break;
368	}
369	case VOLATILE:{
370	jj_consume_token(VOLATILE);
371	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.VOLATILE)); begin = orIfInvalid(begin, token());
372	break;
373	}
374	case STRICTFP:{
375	jj_consume_token(STRICTFP);
376	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.STRICTFP)); begin = orIfInvalid(begin, token());
377	break;
378	}
379	case TRANSITIVE:{
380	jj_consume_token(TRANSITIVE);
381	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.TRANSITIVE)); begin = orIfInvalid(begin, token());
382	break;
383	}
384	case _DEFAULT:{
385	jj_consume_token(_DEFAULT);
386	add(modifiers, new Modifier(tokenRange(), Modifier.Keyword.DEFAULT)); begin = orIfInvalid(begin, token());
387	break;
388	}
389	case AT:{
390	ann = Annotation();
391	annotations = add(annotations, ann); begin = orIfInvalid(begin, ann);
392	break;
393	}
394	default:
395	jj_la1[6] = jj_gen;
396	jj_consume_token(-1);
397	throw new ParseException();
398	}
399	}
400	{if ("" != null) return new ModifierHolder(begin, modifiers, annotations);}
401	throw new IllegalStateException ("Missing return statement in function");
402	}
403
404	/*
405	* Declaration syntax follows.
406	*/
407
408	/**
409	* <strong>
410	* Note that this grammar is deliberately permissive. As a result, this grammar allows any combinations of
411	* class/interface and extends/implements (e.g. an interface implementing an interface).
412	* </strong>
413	* Validations of these combinations are handled at the same time as validating language features used.
414	* Also note that JavaParser handles the hierarchy/specialisations of classes, interfaces, and enums differently to the JLS.
415	* <ul>
416	* <li>This {@code ClassOrInterfaceDeclaration} refers to the {@code NormalClassDeclaration} and {@code NormalInterfaceDeclaration},</li>
417	* <li>while {@code AnnotationTypeDeclaration} and {@code EnumDeclaration} are handled separately within this grammar.</li>
418	* </ul>
419	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.1
420	* <pre>{@code
421	* ClassDeclaration:
422	* NormalClassDeclaration
423	* EnumDeclaration
424	* NormalClassDeclaration:
425	* {ClassModifier} class TypeIdentifier [TypeParameters] [Superclass] [Superinterfaces] ClassBody
426	* }</pre>
427	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.1
428	* <pre>{@code
429	* InterfaceDeclaration:
430	* NormalInterfaceDeclaration
431	* AnnotationTypeDeclaration
432	* NormalInterfaceDeclaration:
433	* {InterfaceModifier} interface TypeIdentifier [TypeParameters] [ExtendsInterfaces] InterfaceBody
434	* }</pre>
435	*/
436	final public ClassOrInterfaceDeclaration ClassOrInterfaceDeclaration(ModifierHolder modifier) throws ParseException {boolean isInterface;
437	SimpleName name;
438	RangedList<TypeParameter> typePar = new RangedList<TypeParameter>(emptyNodeList());
439	NodeList<ClassOrInterfaceType> extList = emptyNodeList();
440	NodeList<ClassOrInterfaceType> impList = emptyNodeList();
441	NodeList<BodyDeclaration<?>> members = emptyNodeList();
442	JavaToken begin = modifier.begin;
443	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
444	case CLASS:{
445	jj_consume_token(CLASS);
446	isInterface = false;
447	break;
448	}
449	case INTERFACE:{
450	jj_consume_token(INTERFACE);
451	isInterface = true;
452	break;
453	}
454	default:
455	jj_la1[7] = jj_gen;
456	jj_consume_token(-1);
457	throw new ParseException();
458	}
459	begin = orIfInvalid(begin, token());
460	name = SimpleName();
461	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
462	case LT:{
463	typePar = TypeParameters();
464	break;
465	}
466	default:
467	jj_la1[8] = jj_gen;
468	;
469	}
470	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
471	case EXTENDS:{
472	extList = ExtendsList();
473	break;
474	}
475	default:
476	jj_la1[9] = jj_gen;
477	;
478	}
479	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
480	case IMPLEMENTS:{
481	impList = ImplementsList();
482	break;
483	}
484	default:
485	jj_la1[10] = jj_gen;
486	;
487	}
488	members = ClassOrInterfaceBody();
489	{if ("" != null) return new ClassOrInterfaceDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, isInterface, name, typePar.list, extList, impList, members);}
490	throw new IllegalStateException ("Missing return statement in function");
491	}
492
493	/**
494	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.1.4
495	* <pre>{@code
496	* Superclass:
497	* extends ClassType
498	* }</pre>
499	* For convenience:
500	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.3
501	* <pre>{@code
502	* ClassOrInterfaceType:
503	* ClassType
504	* InterfaceType
505	* ClassType:
506	* {Annotation} TypeIdentifier [TypeArguments]
507	* PackageName . {Annotation} TypeIdentifier [TypeArguments]
508	* ClassOrInterfaceType . {Annotation} TypeIdentifier [TypeArguments]
509	* InterfaceType:
510	* ClassType
511	* }</pre>
512	*/
513	final public NodeList<ClassOrInterfaceType> ExtendsList() throws ParseException {boolean extendsMoreThanOne = false;
514	NodeList<ClassOrInterfaceType> ret = new NodeList<ClassOrInterfaceType>();
515	ClassOrInterfaceType cit;
516	jj_consume_token(EXTENDS);
517	cit = AnnotatedClassOrInterfaceType();
518	ret.add(cit);
519	label_4:
520	while (true) {
521	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
522	case COMMA:{
523	break;
524	}
525	default:
526	jj_la1[11] = jj_gen;
527	break label_4;
528	}
529	jj_consume_token(COMMA);
530	cit = AnnotatedClassOrInterfaceType();
531	ret.add(cit); extendsMoreThanOne = true;
532	}
533	{if ("" != null) return ret;}
534	throw new IllegalStateException ("Missing return statement in function");
535	}
536
537	/**
538	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.1.5
539	* <pre>{@code
540	* Superinterfaces:
541	* implements InterfaceTypeList
542	* InterfaceTypeList:
543	* InterfaceType {, InterfaceType}
544	* }</pre>
545	* For convenience:
546	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.3
547	* <pre>{@code
548	* ClassOrInterfaceType:
549	* ClassType
550	* InterfaceType
551	* ClassType:
552	* {Annotation} TypeIdentifier [TypeArguments]
553	* PackageName . {Annotation} TypeIdentifier [TypeArguments]
554	* ClassOrInterfaceType . {Annotation} TypeIdentifier [TypeArguments]
555	* InterfaceType:
556	* ClassType
557	* }</pre>
558	*/
559	final public NodeList<ClassOrInterfaceType> ImplementsList() throws ParseException {NodeList<ClassOrInterfaceType> ret = new NodeList<ClassOrInterfaceType>();
560	ClassOrInterfaceType cit;
561	jj_consume_token(IMPLEMENTS);
562	cit = AnnotatedClassOrInterfaceType();
563	ret.add(cit);
564	label_5:
565	while (true) {
566	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
567	case COMMA:{
568	break;
569	}
570	default:
571	jj_la1[12] = jj_gen;
572	break label_5;
573	}
574	jj_consume_token(COMMA);
575	cit = AnnotatedClassOrInterfaceType();
576	ret.add(cit);
577	}
578	{if ("" != null) return ret;}
579	throw new IllegalStateException ("Missing return statement in function");
580	}
581
582	/**
583	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.9
584	* <pre>{@code
585	* EnumDeclaration:
586	* {ClassModifier} enum TypeIdentifier [Superinterfaces] EnumBody
587	* }</pre>
588	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.9.1
589	* <pre>{@code
590	* EnumBody:
591	* { [EnumConstantList] [,] [EnumBodyDeclarations] }
592	* EnumConstantList:
593	* EnumConstant {, EnumConstant}
594	* EnumConstant:
595	* {EnumConstantModifier} Identifier [( [ArgumentList] )] [ClassBody]
596	* EnumConstantModifier:
597	* Annotation
598	* }</pre>
599	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.9.2
600	* <pre>{@code
601	* EnumBodyDeclarations:
602	* ; {ClassBodyDeclaration}
603	* }</pre>
604	*/
605	final public EnumDeclaration EnumDeclaration(ModifierHolder modifier) throws ParseException {SimpleName name;
606	NodeList<ClassOrInterfaceType> impList = emptyNodeList();
607	EnumConstantDeclaration entry;
608	NodeList<EnumConstantDeclaration> entries = emptyNodeList();
609	BodyDeclaration<?> member;
610	NodeList<BodyDeclaration<?>> members = emptyNodeList();
611	JavaToken begin = modifier.begin;
612	jj_consume_token(ENUM);
613	begin = orIfInvalid(begin, token());
614	name = SimpleName();
615	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
616	case IMPLEMENTS:{
617	impList = ImplementsList();
618	break;
619	}
620	default:
621	jj_la1[13] = jj_gen;
622	;
623	}
624	jj_consume_token(LBRACE);
625	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
626	case ENUM:
627	case STRICTFP:
628	case YIELD:
629	case REQUIRES:
630	case TO:
631	case WITH:
632	case OPEN:
633	case OPENS:
634	case USES:
635	case MODULE:
636	case EXPORTS:
637	case PROVIDES:
638	case TRANSITIVE:
639	case IDENTIFIER:
640	case AT:{
641	entry = EnumConstantDeclaration();
642	entries.add(entry);
643	label_6:
644	while (true) {
645	if (jj_2_4(2)) {
646	} else {
647	break label_6;
648	}
649	jj_consume_token(COMMA);
650	entry = EnumConstantDeclaration();
651	entries.add(entry);
652	}
653	break;
654	}
655	default:
656	jj_la1[14] = jj_gen;
657	;
658	}
659	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
660	case COMMA:{
661	jj_consume_token(COMMA);
662	break;
663	}
664	default:
665	jj_la1[15] = jj_gen;
666	;
667	}
668	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
669	case SEMICOLON:{
670	jj_consume_token(SEMICOLON);
671	label_7:
672	while (true) {
673	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
674	case ABSTRACT:
675	case BOOLEAN:
676	case BYTE:
677	case CHAR:
678	case CLASS:
679	case _DEFAULT:
680	case DOUBLE:
681	case ENUM:
682	case FINAL:
683	case FLOAT:
684	case INT:
685	case INTERFACE:
686	case LONG:
687	case NATIVE:
688	case PRIVATE:
689	case PROTECTED:
690	case PUBLIC:
691	case SHORT:
692	case STATIC:
693	case STRICTFP:
694	case SYNCHRONIZED:
695	case TRANSIENT:
696	case VOID:
697	case VOLATILE:
698	case YIELD:
699	case REQUIRES:
700	case TO:
701	case WITH:
702	case OPEN:
703	case OPENS:
704	case USES:
705	case MODULE:
706	case EXPORTS:
707	case PROVIDES:
708	case TRANSITIVE:
709	case IDENTIFIER:
710	case LBRACE:
711	case SEMICOLON:
712	case AT:
713	case LT:{
714	break;
715	}
716	default:
717	jj_la1[16] = jj_gen;
718	break label_7;
719	}
720	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
721	case ABSTRACT:
722	case BOOLEAN:
723	case BYTE:
724	case CHAR:
725	case CLASS:
726	case _DEFAULT:
727	case DOUBLE:
728	case ENUM:
729	case FINAL:
730	case FLOAT:
731	case INT:
732	case INTERFACE:
733	case LONG:
734	case NATIVE:
735	case PRIVATE:
736	case PROTECTED:
737	case PUBLIC:
738	case SHORT:
739	case STATIC:
740	case STRICTFP:
741	case SYNCHRONIZED:
742	case TRANSIENT:
743	case VOID:
744	case VOLATILE:
745	case YIELD:
746	case REQUIRES:
747	case TO:
748	case WITH:
749	case OPEN:
750	case OPENS:
751	case USES:
752	case MODULE:
753	case EXPORTS:
754	case PROVIDES:
755	case TRANSITIVE:
756	case IDENTIFIER:
757	case LBRACE:
758	case AT:
759	case LT:{
760	member = ClassOrInterfaceBodyDeclaration();
761	members = add(members, member);
762	break;
763	}
764	case SEMICOLON:{
765	jj_consume_token(SEMICOLON);
766	break;
767	}
768	default:
769	jj_la1[17] = jj_gen;
770	jj_consume_token(-1);
771	throw new ParseException();
772	}
773	}
774	break;
775	}
776	default:
777	jj_la1[18] = jj_gen;
778	;
779	}
780	jj_consume_token(RBRACE);
781	{if ("" != null) return new EnumDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, name, impList, entries, members);}
782	throw new IllegalStateException ("Missing return statement in function");
783	}
784
785	/**
786	* Note that the {@code EnumConstantModifier} is defined as an {@code Annotation}.
787	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.9.1
788	* <pre>{@code
789	* EnumConstant:
790	* {EnumConstantModifier} Identifier [( [ArgumentList] )] [ClassBody]
791	* EnumConstantModifier:
792	* Annotation
793	* }</pre>
794	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.9.2
795	* <pre>{@code
796	* EnumBodyDeclarations:
797	* ; {ClassBodyDeclaration}
798	* }</pre>
799	*/
800	final public EnumConstantDeclaration EnumConstantDeclaration() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
801	AnnotationExpr ann;
802	SimpleName name;
803	NodeList<Expression> args = emptyNodeList();
804	NodeList<BodyDeclaration<?>> classBody = emptyNodeList();
805	JavaToken begin = INVALID;
806	label_8:
807	while (true) {
808	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
809	case AT:{
810	break;
811	}
812	default:
813	jj_la1[19] = jj_gen;
814	break label_8;
815	}
816	ann = Annotation();
817	annotations = add(annotations, ann); begin = orIfInvalid(begin, ann);
818	}
819	name = SimpleName();
820	begin = orIfInvalid(begin, token());
821	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
822	case LPAREN:{
823	args = Arguments();
824	break;
825	}
826	default:
827	jj_la1[20] = jj_gen;
828	;
829	}
830	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
831	case LBRACE:{
832	classBody = ClassOrInterfaceBody();
833	break;
834	}
835	default:
836	jj_la1[21] = jj_gen;
837	;
838	}
839	{if ("" != null) return new EnumConstantDeclaration(range(begin, token()), annotations, name, args, classBody);}
840	throw new IllegalStateException ("Missing return statement in function");
841	}
842
843	/**
844	* If the list inside the returned RangedList is null, there are no brackets.
845	* If it is empty, there are brackets, but nothing is in them <>.
846	* The normal case is that it contains TypeParameters, like <A, B, C>.
847	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.1.2
848	* <pre>{@code
849	* TypeParameters:
850	* < TypeParameterList >
851	* TypeParameterList:
852	* TypeParameter {, TypeParameter}
853	* }</pre>
854	* For Convenience:
855	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.4
856	* <pre>{@code
857	* TypeParameter:
858	* {TypeParameterModifier} TypeIdentifier [TypeBound]
859	* TypeParameterModifier:
860	* Annotation
861	* TypeBound:
862	* extends TypeVariable
863	* extends ClassOrInterfaceType {AdditionalBound}
864	* AdditionalBound:
865	* & InterfaceType
866	* }</pre>
867	*/
868	final public RangedList<TypeParameter> TypeParameters() throws ParseException {RangedList<TypeParameter> ret = new RangedList<TypeParameter>(new NodeList<TypeParameter>());
869	TypeParameter tp;
870	NodeList<AnnotationExpr> annotations;
871	jj_consume_token(LT);
872	ret.beginAt(token());
873	annotations = Annotations();
874	tp = TypeParameter(annotations);
875	ret.add(tp); annotations = null;
876	label_9:
877	while (true) {
878	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
879	case COMMA:{
880	break;
881	}
882	default:
883	jj_la1[22] = jj_gen;
884	break label_9;
885	}
886	jj_consume_token(COMMA);
887	annotations = Annotations();
888	tp = TypeParameter(annotations);
889	ret.add(tp); annotations = null;
890	}
891	jj_consume_token(GT);
892	ret.endAt(token());
893	{if ("" != null) return ret;}
894	throw new IllegalStateException ("Missing return statement in function");
895	}
896
897	/**
898	* Note that the {@code TypeParameterModifier} is defined as an {@code Annotation}.
899	* Note that the annotations are passed as a parameter to this grammar entry.
900	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.4
901	* <pre>{@code
902	* TypeParameter:
903	* {TypeParameterModifier} TypeIdentifier [TypeBound]
904	* TypeParameterModifier:
905	* Annotation
906	* TypeBound:
907	* extends TypeVariable
908	* extends ClassOrInterfaceType {AdditionalBound}
909	* AdditionalBound:
910	* & InterfaceType
911	* }</pre>
912	*/
913	final public TypeParameter TypeParameter(NodeList<AnnotationExpr> annotations) throws ParseException {SimpleName name;
914	NodeList<ClassOrInterfaceType> typeBound = emptyNodeList();
915	JavaToken begin;
916	// Annotations are passed as a parameter to this grammar entry.
917	name = SimpleName();
918	begin=token();
919	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
920	case EXTENDS:{
921	typeBound = TypeBound();
922	break;
923	}
924	default:
925	jj_la1[23] = jj_gen;
926	;
927	}
928	{if ("" != null) return new TypeParameter(range(begin, token()), name, typeBound, annotations);}
929	throw new IllegalStateException ("Missing return statement in function");
930	}
931
932	/**
933	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.4
934	* <pre>{@code
935	* TypeBound:
936	* extends TypeVariable
937	* extends ClassOrInterfaceType {AdditionalBound}
938	* AdditionalBound:
939	* & InterfaceType
940	* }</pre>
941	* For Convenience:
942	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.3
943	* <pre>{@code
944	* ClassOrInterfaceType:
945	* ClassType
946	* InterfaceType
947	* ClassType:
948	* {Annotation} TypeIdentifier [TypeArguments]
949	* PackageName . {Annotation} TypeIdentifier [TypeArguments]
950	* ClassOrInterfaceType . {Annotation} TypeIdentifier [TypeArguments]
951	* InterfaceType:
952	* ClassType
953	* TypeVariable:
954	* {Annotation} TypeIdentifier
955	* }</pre>
956	*/
957	final public NodeList<ClassOrInterfaceType> TypeBound() throws ParseException {NodeList<ClassOrInterfaceType> ret = emptyNodeList();
958	ClassOrInterfaceType cit;
959	jj_consume_token(EXTENDS);
960	cit = AnnotatedClassOrInterfaceType();
961	ret.add(cit);
962	label_10:
963	while (true) {
964	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
965	case BIT_AND:{
966	break;
967	}
968	default:
969	jj_la1[24] = jj_gen;
970	break label_10;
971	}
972	jj_consume_token(BIT_AND);
973	cit = AnnotatedClassOrInterfaceType();
974	ret.add(cit);
975	}
976	{if ("" != null) return ret;}
977	throw new IllegalStateException ("Missing return statement in function");
978	}
979
980	/**
981	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.1.6
982	* <pre>{@code
983	* ClassBody:
984	* { {ClassBodyDeclaration} }
985	* ClassBodyDeclaration:
986	* ClassMemberDeclaration
987	* InstanceInitializer
988	* StaticInitializer
989	* ConstructorDeclaration
990	* ClassMemberDeclaration:
991	* FieldDeclaration
992	* MethodDeclaration
993	* ClassDeclaration
994	* InterfaceDeclaration
995	* ;
996	* }</pre>
997	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.1.4
998	* <pre>{@code
999	* InterfaceBody:
1000	* { {InterfaceMemberDeclaration} }
1001	* InterfaceMemberDeclaration:
1002	* ConstantDeclaration
1003	* InterfaceMethodDeclaration
1004	* ClassDeclaration
1005	* InterfaceDeclaration
1006	* ;
1007	* }</pre>
1008	*/
1009	final public NodeList<BodyDeclaration<?>> ClassOrInterfaceBody() throws ParseException {NodeList<BodyDeclaration<?>> ret = emptyNodeList();
1010	BodyDeclaration member;
1011	jj_consume_token(LBRACE);
1012	label_11:
1013	while (true) {
1014	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1015	case ABSTRACT:
1016	case BOOLEAN:
1017	case BYTE:
1018	case CHAR:
1019	case CLASS:
1020	case _DEFAULT:
1021	case DOUBLE:
1022	case ENUM:
1023	case FINAL:
1024	case FLOAT:
1025	case INT:
1026	case INTERFACE:
1027	case LONG:
1028	case NATIVE:
1029	case PRIVATE:
1030	case PROTECTED:
1031	case PUBLIC:
1032	case SHORT:
1033	case STATIC:
1034	case STRICTFP:
1035	case SYNCHRONIZED:
1036	case TRANSIENT:
1037	case VOID:
1038	case VOLATILE:
1039	case YIELD:
1040	case REQUIRES:
1041	case TO:
1042	case WITH:
1043	case OPEN:
1044	case OPENS:
1045	case USES:
1046	case MODULE:
1047	case EXPORTS:
1048	case PROVIDES:
1049	case TRANSITIVE:
1050	case IDENTIFIER:
1051	case LBRACE:
1052	case SEMICOLON:
1053	case AT:
1054	case LT:{
1055	break;
1056	}
1057	default:
1058	jj_la1[25] = jj_gen;
1059	break label_11;
1060	}
1061	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1062	case ABSTRACT:
1063	case BOOLEAN:
1064	case BYTE:
1065	case CHAR:
1066	case CLASS:
1067	case _DEFAULT:
1068	case DOUBLE:
1069	case ENUM:
1070	case FINAL:
1071	case FLOAT:
1072	case INT:
1073	case INTERFACE:
1074	case LONG:
1075	case NATIVE:
1076	case PRIVATE:
1077	case PROTECTED:
1078	case PUBLIC:
1079	case SHORT:
1080	case STATIC:
1081	case STRICTFP:
1082	case SYNCHRONIZED:
1083	case TRANSIENT:
1084	case VOID:
1085	case VOLATILE:
1086	case YIELD:
1087	case REQUIRES:
1088	case TO:
1089	case WITH:
1090	case OPEN:
1091	case OPENS:
1092	case USES:
1093	case MODULE:
1094	case EXPORTS:
1095	case PROVIDES:
1096	case TRANSITIVE:
1097	case IDENTIFIER:
1098	case LBRACE:
1099	case AT:
1100	case LT:{
1101	member = ClassOrInterfaceBodyDeclaration();
1102	ret.add(member);
1103	break;
1104	}
1105	case SEMICOLON:{
1106	jj_consume_token(SEMICOLON);
1107	break;
1108	}
1109	default:
1110	jj_la1[26] = jj_gen;
1111	jj_consume_token(-1);
1112	throw new ParseException();
1113	}
1114	}
1115	jj_consume_token(RBRACE);
1116	{if ("" != null) return ret;}
1117	throw new IllegalStateException ("Missing return statement in function");
1118	}
1119
1120	/**
1121	* Note that {@code ClassDeclaration} and {@code InterfaceDeclaration} (in the JLS) include enum and annotation declarations.
1122	* Note that {@code InstanceInitializer} and {@code StaticInitializer} are treated as an {@code Initializer} with an
1123	* optional {@code static} modifier in JavaParser.
1124	* TODO: Investigate the {@code ClassBodyDeclaration} parts existing within an interface - is permitting this a potential problem?
1125	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.1.6
1126	* <pre>{@code
1127	* ClassBody:
1128	* { {ClassBodyDeclaration} }
1129	* ClassBodyDeclaration:
1130	* ClassMemberDeclaration
1131	* InstanceInitializer
1132	* StaticInitializer
1133	* ConstructorDeclaration
1134	* ClassMemberDeclaration:
1135	* FieldDeclaration
1136	* MethodDeclaration
1137	* ClassDeclaration
1138	* InterfaceDeclaration
1139	* ;
1140	* }</pre>
1141	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.1.4
1142	* <pre>{@code
1143	* InterfaceBody:
1144	* { {InterfaceMemberDeclaration} }
1145	* InterfaceMemberDeclaration:
1146	* ConstantDeclaration
1147	* InterfaceMethodDeclaration
1148	* ClassDeclaration
1149	* InterfaceDeclaration
1150	* ;
1151	* }</pre>
1152	*/
1153	final public BodyDeclaration<?> ClassOrInterfaceBodyDeclaration() throws ParseException {ModifierHolder modifiers;
1154	BodyDeclaration<?> ret;
1155	if (jj_2_9(2)) {
1156	ret = InitializerDeclaration();
1157	} else {
1158	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1159	case ABSTRACT:
1160	case BOOLEAN:
1161	case BYTE:
1162	case CHAR:
1163	case CLASS:
1164	case _DEFAULT:
1165	case DOUBLE:
1166	case ENUM:
1167	case FINAL:
1168	case FLOAT:
1169	case INT:
1170	case INTERFACE:
1171	case LONG:
1172	case NATIVE:
1173	case PRIVATE:
1174	case PROTECTED:
1175	case PUBLIC:
1176	case SHORT:
1177	case STATIC:
1178	case STRICTFP:
1179	case SYNCHRONIZED:
1180	case TRANSIENT:
1181	case VOID:
1182	case VOLATILE:
1183	case YIELD:
1184	case REQUIRES:
1185	case TO:
1186	case WITH:
1187	case OPEN:
1188	case OPENS:
1189	case USES:
1190	case MODULE:
1191	case EXPORTS:
1192	case PROVIDES:
1193	case TRANSITIVE:
1194	case IDENTIFIER:
1195	case AT:
1196	case LT:{
1197	// Just get all the modifiers out of the way. If you want to do
1198	// more checks, pass the modifiers down to the member
1199	modifiers = Modifiers();
1200	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1201	case CLASS:
1202	case INTERFACE:{
1203	ret = ClassOrInterfaceDeclaration(modifiers);
1204	break;
1205	}
1206	default:
1207	jj_la1[27] = jj_gen;
1208	if (jj_2_5(2147483647)) {
1209	ret = EnumDeclaration(modifiers);
1210	} else if (jj_2_6(2147483647)) {
1211	ret = AnnotationTypeDeclaration(modifiers);
1212	} else if (jj_2_7(2147483647)) {
1213	ret = ConstructorDeclaration(modifiers);
1214	} else if (jj_2_8(2147483647)) {
1215	ret = FieldDeclaration(modifiers);
1216	} else {
1217	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1218	case BOOLEAN:
1219	case BYTE:
1220	case CHAR:
1221	case DOUBLE:
1222	case ENUM:
1223	case FLOAT:
1224	case INT:
1225	case LONG:
1226	case SHORT:
1227	case STRICTFP:
1228	case VOID:
1229	case YIELD:
1230	case REQUIRES:
1231	case TO:
1232	case WITH:
1233	case OPEN:
1234	case OPENS:
1235	case USES:
1236	case MODULE:
1237	case EXPORTS:
1238	case PROVIDES:
1239	case TRANSITIVE:
1240	case IDENTIFIER:
1241	case AT:
1242	case LT:{
1243	ret = MethodDeclaration(modifiers);
1244	break;
1245	}
1246	default:
1247	jj_la1[28] = jj_gen;
1248	jj_consume_token(-1);
1249	throw new ParseException();
1250	}
1251	}
1252	}
1253	break;
1254	}
1255	default:
1256	jj_la1[29] = jj_gen;
1257	jj_consume_token(-1);
1258	throw new ParseException();
1259	}
1260	}
1261	{if ("" != null) return ret;}
1262	throw new IllegalStateException ("Missing return statement in function");
1263	}
1264
1265	/**
1266	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.3
1267	* <pre>{@code
1268	* FieldDeclaration:
1269	* {FieldModifier} UnannType VariableDeclaratorList ;
1270	* VariableDeclaratorList:
1271	* VariableDeclarator {, VariableDeclarator}
1272	* VariableDeclarator:
1273	* VariableDeclaratorId [= VariableInitializer]
1274	* VariableDeclaratorId:
1275	* Identifier [Dims]
1276	* VariableInitializer:
1277	* Expression
1278	* ArrayInitializer
1279	* }</pre>
1280	*/
1281	final public FieldDeclaration FieldDeclaration(ModifierHolder modifier) throws ParseException {Type partialType;
1282	NodeList<VariableDeclarator> variables = new NodeList<VariableDeclarator>();
1283	VariableDeclarator val;
1284	// Modifiers are already matched in the caller
1285	partialType = Type(emptyNodeList());
1286	val = VariableDeclarator(partialType);
1287	variables.add(val);
1288	label_12:
1289	while (true) {
1290	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1291	case COMMA:{
1292	break;
1293	}
1294	default:
1295	jj_la1[30] = jj_gen;
1296	break label_12;
1297	}
1298	jj_consume_token(COMMA);
1299	val = VariableDeclarator(partialType);
1300	variables.add(val);
1301	}
1302	jj_consume_token(SEMICOLON);
1303	JavaToken begin = orIfInvalid(modifier.begin, partialType);
1304	{if ("" != null) return new FieldDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, variables);}
1305	throw new IllegalStateException ("Missing return statement in function");
1306	}
1307
1308	/**
1309	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.3
1310	* <pre>{@code
1311	* VariableDeclarator:
1312	* VariableDeclaratorId [= VariableInitializer]
1313	* VariableDeclaratorId:
1314	* Identifier [Dims]
1315	* VariableInitializer:
1316	* Expression
1317	* ArrayInitializer
1318	* }</pre>
1319	*/
1320	final public VariableDeclarator VariableDeclarator(Type partialType) throws ParseException {Pair<SimpleName, List<ArrayBracketPair>> id;
1321	Expression init = null;
1322	id = VariableDeclaratorId();
1323	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1324	case ASSIGN:{
1325	jj_consume_token(ASSIGN);
1326	init = VariableInitializer();
1327	break;
1328	}
1329	default:
1330	jj_la1[31] = jj_gen;
1331	;
1332	}
1333	{if ("" != null) return new VariableDeclarator(range(id.a, token()), juggleArrayType(partialType, id.b), id.a, init);}
1334	throw new IllegalStateException ("Missing return statement in function");
1335	}
1336
1337	/**
1338	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.3
1339	* <pre>{@code
1340	* VariableDeclaratorId:
1341	* Identifier [Dims]
1342	* }</pre>
1343	* For convenience:
1344	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-3.html#jls-Identifier
1345	* <pre>{@code
1346	* Identifier:
1347	* IdentifierChars but not a Keyword or BooleanLiteral or NullLiteral
1348	* IdentifierChars:
1349	* JavaLetter {JavaLetterOrDigit}
1350	* JavaLetter:
1351	* any Unicode character that is a "Java letter"
1352	* JavaLetterOrDigit:
1353	* any Unicode character that is a "Java letter-or-digit"
1354	* }</pre>
1355	* For convenience:
1356	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-Dims
1357	* <pre>{@code
1358	* Dims:
1359	* {Annotation} [ ] {{Annotation} [ ]}
1360	* }</pre>
1361	*/
1362	final public Pair<SimpleName, List<ArrayBracketPair>> VariableDeclaratorId() throws ParseException {SimpleName name;
1363	JavaToken begin;
1364	ArrayBracketPair arrayBracketPair;
1365	List<ArrayBracketPair> arrayBracketPairs = new ArrayList<ArrayBracketPair>(0);
1366	name = SimpleName();
1367	begin=token();
1368	label_13:
1369	while (true) {
1370	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1371	case LBRACKET:
1372	case AT:{
1373	break;
1374	}
1375	default:
1376	jj_la1[32] = jj_gen;
1377	break label_13;
1378	}
1379	arrayBracketPair = ArrayBracketPair(Origin.NAME);
1380	arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair);
1381	}
1382	if(storeTokens) {
1383	name.setTokenRange(name.getTokenRange().get().withEnd(token()));
1384	}
1385	{if ("" != null) return new Pair(name, arrayBracketPairs);}
1386	throw new IllegalStateException ("Missing return statement in function");
1387	}
1388
1389	/**
1390	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.3
1391	* <pre>{@code
1392	* VariableInitializer:
1393	* Expression
1394	* ArrayInitializer
1395	* }</pre>
1396	*/
1397	final public Expression VariableInitializer() throws ParseException {Expression ret;
1398	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1399	case LBRACE:{
1400	ret = ArrayInitializer();
1401	break;
1402	}
1403	case BOOLEAN:
1404	case BYTE:
1405	case CHAR:
1406	case DOUBLE:
1407	case ENUM:
1408	case FALSE:
1409	case FLOAT:
1410	case INT:
1411	case LONG:
1412	case NEW:
1413	case NULL:
1414	case SHORT:
1415	case STRICTFP:
1416	case SUPER:
1417	case SWITCH:
1418	case THIS:
1419	case TRUE:
1420	case VOID:
1421	case YIELD:
1422	case REQUIRES:
1423	case TO:
1424	case WITH:
1425	case OPEN:
1426	case OPENS:
1427	case USES:
1428	case MODULE:
1429	case EXPORTS:
1430	case PROVIDES:
1431	case TRANSITIVE:
1432	case LONG_LITERAL:
1433	case INTEGER_LITERAL:
1434	case FLOATING_POINT_LITERAL:
1435	case CHARACTER_LITERAL:
1436	case STRING_LITERAL:
1437	case TEXT_BLOCK_LITERAL:
1438	case IDENTIFIER:
1439	case LPAREN:
1440	case AT:
1441	case BANG:
1442	case TILDE:
1443	case INCR:
1444	case DECR:
1445	case PLUS:
1446	case MINUS:{
1447	ret = Expression();
1448	break;
1449	}
1450	default:
1451	jj_la1[33] = jj_gen;
1452	jj_consume_token(-1);
1453	throw new ParseException();
1454	}
1455	{if ("" != null) return ret;}
1456	throw new IllegalStateException ("Missing return statement in function");
1457	}
1458
1459	/**
1460	* An array initializer is written as a comma-separated list of expressions, enclosed by braces { and }.
1461	* A trailing comma may appear after the last expression in an array initializer and is ignored.
1462	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-10.html#jls-10.6
1463	* <pre>{@code
1464	* ArrayInitializer:
1465	* { [VariableInitializerList] [,] }
1466	* VariableInitializerList:
1467	* VariableInitializer {, VariableInitializer}
1468	* }</pre>
1469	* <pre>{@code
1470	* VariableInitializer:
1471	* Expression
1472	* ArrayInitializer
1473	* }</pre>
1474	*/
1475	final public ArrayInitializerExpr ArrayInitializer() throws ParseException {NodeList<Expression> values = emptyNodeList();
1476	Expression val;
1477	JavaToken begin;
1478	jj_consume_token(LBRACE);
1479	begin=token();
1480	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1481	case BOOLEAN:
1482	case BYTE:
1483	case CHAR:
1484	case DOUBLE:
1485	case ENUM:
1486	case FALSE:
1487	case FLOAT:
1488	case INT:
1489	case LONG:
1490	case NEW:
1491	case NULL:
1492	case SHORT:
1493	case STRICTFP:
1494	case SUPER:
1495	case SWITCH:
1496	case THIS:
1497	case TRUE:
1498	case VOID:
1499	case YIELD:
1500	case REQUIRES:
1501	case TO:
1502	case WITH:
1503	case OPEN:
1504	case OPENS:
1505	case USES:
1506	case MODULE:
1507	case EXPORTS:
1508	case PROVIDES:
1509	case TRANSITIVE:
1510	case LONG_LITERAL:
1511	case INTEGER_LITERAL:
1512	case FLOATING_POINT_LITERAL:
1513	case CHARACTER_LITERAL:
1514	case STRING_LITERAL:
1515	case TEXT_BLOCK_LITERAL:
1516	case IDENTIFIER:
1517	case LPAREN:
1518	case LBRACE:
1519	case AT:
1520	case BANG:
1521	case TILDE:
1522	case INCR:
1523	case DECR:
1524	case PLUS:
1525	case MINUS:{
1526	val = VariableInitializer();
1527	values = add(values, val);
1528	label_14:
1529	while (true) {
1530	if (jj_2_10(2)) {
1531	} else {
1532	break label_14;
1533	}
1534	jj_consume_token(COMMA);
1535	val = VariableInitializer();
1536	values = add(values, val);
1537	}
1538	break;
1539	}
1540	default:
1541	jj_la1[34] = jj_gen;
1542	;
1543	}
1544	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1545	case COMMA:{
1546	jj_consume_token(COMMA);
1547	break;
1548	}
1549	default:
1550	jj_la1[35] = jj_gen;
1551	;
1552	}
1553	jj_consume_token(RBRACE);
1554	{if ("" != null) return new ArrayInitializerExpr(range(begin, token()), values);}
1555	throw new IllegalStateException ("Missing return statement in function");
1556	}
1557
1558	/**
1559	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.4
1560	* <pre>{@code
1561	* MethodDeclaration:
1562	* {MethodModifier} MethodHeader MethodBody
1563	* MethodHeader:
1564	* Result MethodDeclarator [Throws]
1565	* TypeParameters {Annotation} Result MethodDeclarator [Throws]
1566	* MethodDeclarator:
1567	* Identifier ( [ReceiverParameter ,] [FormalParameterList] ) [Dims]
1568	* ReceiverParameter:
1569	* {Annotation} UnannType [Identifier .] this
1570	* }</pre>
1571	*/
1572	final public MethodDeclaration MethodDeclaration(ModifierHolder modifier) throws ParseException {RangedList<TypeParameter> typeParameters = new RangedList<TypeParameter>(emptyNodeList());
1573	Type type;
1574	SimpleName name;
1575	Pair<NodeList<Parameter>, ReceiverParameter> parameters = new Pair<NodeList<Parameter>, ReceiverParameter>(emptyNodeList(), null);
1576	ArrayBracketPair arrayBracketPair;
1577	List<ArrayBracketPair> arrayBracketPairs = new ArrayList<ArrayBracketPair>(0);
1578	NodeList<ReferenceType> throws_ = emptyNodeList();
1579	BlockStmt body = null;
1580	NodeList<AnnotationExpr> annotations;
1581	JavaToken begin = modifier.begin;
1582	ReferenceType throwType;
1583	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1584	case LT:{
1585	typeParameters = TypeParameters();
1586	begin = orIfInvalid(begin, typeParameters.range.getBegin());
1587	break;
1588	}
1589	default:
1590	jj_la1[36] = jj_gen;
1591	;
1592	}
1593	annotations = Annotations();
1594	modifier.annotations.addAll(annotations); begin = orIfInvalid(begin, nodeListBegin(annotations));
1595	type = ResultType(emptyNodeList());
1596	begin = orIfInvalid(begin, type);
1597	name = SimpleName();
1598	parameters = Parameters();
1599	label_15:
1600	while (true) {
1601	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1602	case LBRACKET:
1603	case AT:{
1604	break;
1605	}
1606	default:
1607	jj_la1[37] = jj_gen;
1608	break label_15;
1609	}
1610	arrayBracketPair = ArrayBracketPair(Origin.NAME);
1611	arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair);
1612	}
1613	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1614	case THROWS:{
1615	jj_consume_token(THROWS);
1616	throwType = AnnotatedReferenceType();
1617	throws_ = add(throws_, throwType);
1618	label_16:
1619	while (true) {
1620	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1621	case COMMA:{
1622	break;
1623	}
1624	default:
1625	jj_la1[38] = jj_gen;
1626	break label_16;
1627	}
1628	jj_consume_token(COMMA);
1629	throwType = AnnotatedReferenceType();
1630	throws_ = add(throws_, throwType);
1631	}
1632	break;
1633	}
1634	default:
1635	jj_la1[39] = jj_gen;
1636	;
1637	}
1638	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1639	case LBRACE:{
1640	body = Block();
1641	break;
1642	}
1643	case SEMICOLON:{
1644	jj_consume_token(SEMICOLON);
1645	break;
1646	}
1647	default:
1648	jj_la1[40] = jj_gen;
1649	jj_consume_token(-1);
1650	throw new ParseException();
1651	}
1652	type = juggleArrayType(type, arrayBracketPairs);
1653	{if ("" != null) return new MethodDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, typeParameters.list, type, name, parameters.a, throws_, body, parameters.b);}
1654	throw new IllegalStateException ("Missing return statement in function");
1655	}
1656
1657	// TODO: JLS Has type and unannotated type, while JavaParser has type and annotated type.
1658	final public ReferenceType AnnotatedReferenceType() throws ParseException {NodeList<AnnotationExpr> annotations;
1659	ReferenceType type;
1660	annotations = Annotations();
1661	type = ReferenceType(annotations);
1662	{if ("" != null) return type;}
1663	throw new IllegalStateException ("Missing return statement in function");
1664	}
1665
1666	// TODO: JLS Has type and unannotated type, while JavaParser has type and annotated type.
1667	final public Type AnnotatedType() throws ParseException {NodeList<AnnotationExpr> annotations;
1668	Type type;
1669	annotations = Annotations();
1670	type = Type(annotations);
1671	{if ("" != null) return type;}
1672	throw new IllegalStateException ("Missing return statement in function");
1673	}
1674
1675	/**
1676	* The JLS refers to parameters as {@code FormalParameter}.
1677	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.4.1
1678	* <pre>{@code
1679	* FormalParameterList:
1680	* FormalParameter {, FormalParameter}
1681	* FormalParameter:
1682	* {VariableModifier} UnannType VariableDeclaratorId
1683	* VariableArityParameter
1684	* VariableArityParameter:
1685	* {VariableModifier} UnannType {Annotation} ... Identifier
1686	* VariableModifier:
1687	* Annotation
1688	* final
1689	* }</pre>
1690	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.4
1691	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-ReceiverParameter
1692	* <pre>{@code
1693	* MethodDeclarator:
1694	* Identifier ( [ReceiverParameter ,] [FormalParameterList] ) [Dims]
1695	* ReceiverParameter:
1696	* {Annotation} UnannType [Identifier .] this
1697	* }</pre>
1698	*/
1699	final public Pair<NodeList<Parameter>, ReceiverParameter> Parameters() throws ParseException {NodeList<Parameter> ret = emptyNodeList();
1700	Parameter par;
1701	ReceiverParameter rp = null;
1702	jj_consume_token(LPAREN);
1703	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1704	case ABSTRACT:
1705	case BOOLEAN:
1706	case BYTE:
1707	case CHAR:
1708	case _DEFAULT:
1709	case DOUBLE:
1710	case ENUM:
1711	case FINAL:
1712	case FLOAT:
1713	case INT:
1714	case LONG:
1715	case NATIVE:
1716	case PRIVATE:
1717	case PROTECTED:
1718	case PUBLIC:
1719	case SHORT:
1720	case STATIC:
1721	case STRICTFP:
1722	case SYNCHRONIZED:
1723	case TRANSIENT:
1724	case VOLATILE:
1725	case YIELD:
1726	case REQUIRES:
1727	case TO:
1728	case WITH:
1729	case OPEN:
1730	case OPENS:
1731	case USES:
1732	case MODULE:
1733	case EXPORTS:
1734	case PROVIDES:
1735	case TRANSITIVE:
1736	case IDENTIFIER:
1737	case AT:{
1738	if (jj_2_11(2147483647)) {
1739	rp = ReceiverParameter();
1740	} else {
1741	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1742	case ABSTRACT:
1743	case BOOLEAN:
1744	case BYTE:
1745	case CHAR:
1746	case _DEFAULT:
1747	case DOUBLE:
1748	case ENUM:
1749	case FINAL:
1750	case FLOAT:
1751	case INT:
1752	case LONG:
1753	case NATIVE:
1754	case PRIVATE:
1755	case PROTECTED:
1756	case PUBLIC:
1757	case SHORT:
1758	case STATIC:
1759	case STRICTFP:
1760	case SYNCHRONIZED:
1761	case TRANSIENT:
1762	case VOLATILE:
1763	case YIELD:
1764	case REQUIRES:
1765	case TO:
1766	case WITH:
1767	case OPEN:
1768	case OPENS:
1769	case USES:
1770	case MODULE:
1771	case EXPORTS:
1772	case PROVIDES:
1773	case TRANSITIVE:
1774	case IDENTIFIER:
1775	case AT:{
1776	par = Parameter();
1777	ret = add(ret, par);
1778	break;
1779	}
1780	default:
1781	jj_la1[41] = jj_gen;
1782	jj_consume_token(-1);
1783	throw new ParseException();
1784	}
1785	}
1786	label_17:
1787	while (true) {
1788	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1789	case COMMA:{
1790	break;
1791	}
1792	default:
1793	jj_la1[42] = jj_gen;
1794	break label_17;
1795	}
1796	jj_consume_token(COMMA);
1797	par = Parameter();
1798	ret = add(ret, par);
1799	}
1800	break;
1801	}
1802	default:
1803	jj_la1[43] = jj_gen;
1804	;
1805	}
1806	jj_consume_token(RPAREN);
1807	{if ("" != null) return new Pair(ret, rp);}
1808	throw new IllegalStateException ("Missing return statement in function");
1809	}
1810
1811	/**
1812	* Note: Similar, but not identical to, {@code FormalParameter}.
1813	* Note: Distinction between {@code LambdaParameters} and {@code InferredLambdaParameters} is presence of types.
1814	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.27.1
1815	* <pre>{@code
1816	* LambdaParameters:
1817	* ( [LambdaParameterList] )
1818	* Identifier
1819	* LambdaParameterList:
1820	* LambdaParameter {, LambdaParameter}
1821	* Identifier {, Identifier}
1822	* LambdaParameter:
1823	* {VariableModifier} LambdaParameterType VariableDeclaratorId
1824	* VariableArityParameter
1825	* LambdaParameterType:
1826	* UnannType
1827	* var
1828	* }</pre>
1829	* For Convenience:
1830	* <pre>{@code
1831	* VariableArityParameter:
1832	* {VariableModifier} UnannType {Annotation} ... Identifier
1833	* VariableModifier:
1834	* Annotation
1835	* final
1836	* VariableDeclaratorId:
1837	* Identifier [Dims]
1838	* Dims:
1839	* {Annotation} [ ] {{Annotation} [ ]}
1840	* }</pre>
1841	*/
1842	final public NodeList<Parameter> LambdaParameters() throws ParseException {NodeList<Parameter> ret = null;
1843	Parameter par;
1844	par = Parameter();
1845	ret = add(ret, par);
1846	label_18:
1847	while (true) {
1848	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1849	case COMMA:{
1850	break;
1851	}
1852	default:
1853	jj_la1[44] = jj_gen;
1854	break label_18;
1855	}
1856	jj_consume_token(COMMA);
1857	par = Parameter();
1858	ret = add(ret, par);
1859	}
1860	{if ("" != null) return ret;}
1861	throw new IllegalStateException ("Missing return statement in function");
1862	}
1863
1864	/**
1865	* Note: Similar, but not identical to, {@code FormalParameter}.
1866	* Note: Distinction between {@code LambdaParameters} and {@code InferredLambdaParameters} is presence of types.
1867	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.27.1
1868	* <pre>{@code
1869	* LambdaParameters:
1870	* ( [LambdaParameterList] )
1871	* Identifier
1872	* LambdaParameterList:
1873	* LambdaParameter {, LambdaParameter}
1874	* Identifier {, Identifier}
1875	* LambdaParameter:
1876	* {VariableModifier} LambdaParameterType VariableDeclaratorId
1877	* VariableArityParameter
1878	* LambdaParameterType:
1879	* UnannType
1880	* var
1881	* }</pre>
1882	* For Convenience:
1883	* <pre>{@code
1884	* VariableArityParameter:
1885	* {VariableModifier} UnannType {Annotation} ... Identifier
1886	* VariableModifier:
1887	* Annotation
1888	* final
1889	* VariableDeclaratorId:
1890	* Identifier [Dims]
1891	* Dims:
1892	* {Annotation} [ ] {{Annotation} [ ]}
1893	* }</pre>
1894	*/
1895	final public NodeList<Parameter> InferredLambdaParameters() throws ParseException {NodeList<Parameter> ret = null;
1896	Pair<SimpleName, List<ArrayBracketPair>> id;
1897	id = VariableDeclaratorId();
1898	ret = add(ret, new Parameter(range(id.a, id.a), new NodeList<Modifier>(), emptyNodeList(), new UnknownType(), false, emptyNodeList(), id.a));
1899	label_19:
1900	while (true) {
1901	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1902	case COMMA:{
1903	break;
1904	}
1905	default:
1906	jj_la1[45] = jj_gen;
1907	break label_19;
1908	}
1909	jj_consume_token(COMMA);
1910	id = VariableDeclaratorId();
1911	ret = add(ret, new Parameter(range(id.a, id.a), new NodeList<Modifier>(), emptyNodeList(), new UnknownType(), false, emptyNodeList(), id.a));
1912	}
1913	{if ("" != null) return ret;}
1914	throw new IllegalStateException ("Missing return statement in function");
1915	}
1916
1917	/**
1918	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.4.1
1919	* <pre>{@code
1920	* FormalParameter:
1921	* {VariableModifier} UnannType VariableDeclaratorId
1922	* VariableArityParameter
1923	* VariableArityParameter:
1924	* {VariableModifier} UnannType {Annotation} ... Identifier
1925	* VariableModifier:
1926	* Annotation
1927	* final
1928	* }</pre>
1929	*/
1930	final public Parameter Parameter() throws ParseException {ModifierHolder modifier;
1931	Type partialType;
1932	boolean isVarArg = false;
1933	Pair<SimpleName, List<ArrayBracketPair>> id;
1934	NodeList<AnnotationExpr> varArgAnnotations = emptyNodeList();
1935	modifier = Modifiers();
1936	partialType = Type(emptyNodeList());
1937	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
1938	case AT:
1939	case ELLIPSIS:{
1940	varArgAnnotations = Annotations();
1941	jj_consume_token(ELLIPSIS);
1942	isVarArg = true;
1943	break;
1944	}
1945	default:
1946	jj_la1[46] = jj_gen;
1947	;
1948	}
1949	id = VariableDeclaratorId();
1950	JavaToken begin = orIfInvalid(modifier.begin, partialType);
1951	{if ("" != null) return new Parameter(range(begin, token()), modifier.modifiers, modifier.annotations, juggleArrayType(partialType, id.b), isVarArg, varArgAnnotations, id.a);}
1952	throw new IllegalStateException ("Missing return statement in function");
1953	}
1954
1955	/**
1956	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.4
1957	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-ReceiverParameter
1958	* <pre>{@code
1959	* MethodDeclarator:
1960	* Identifier ( [ReceiverParameter ,] [FormalParameterList] ) [Dims]
1961	* ReceiverParameter:
1962	* {Annotation} UnannType [Identifier .] this
1963	* }</pre>
1964	*/
1965	final public ReceiverParameter ReceiverParameter() throws ParseException {Type partialType;
1966	Name id;
1967	NodeList<AnnotationExpr> annotations = emptyNodeList();
1968	annotations = Annotations();
1969	partialType = Type(emptyNodeList());
1970	id = ReceiverParameterId();
1971	{if ("" != null) return new ReceiverParameter(range(partialType, token()), annotations, partialType, id);}
1972	throw new IllegalStateException ("Missing return statement in function");
1973	}
1974
1975	/**
1976	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.4
1977	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-ReceiverParameter
1978	* <pre>{@code
1979	* MethodDeclarator:
1980	* Identifier ( [ReceiverParameter ,] [FormalParameterList] ) [Dims]
1981	* ReceiverParameter:
1982	* {Annotation} UnannType [Identifier .] this
1983	* }</pre>
1984	*/
1985	final public Name ReceiverParameterId() throws ParseException {Name ret = null;
1986	if (jj_2_12(2147483647)) {
1987	ret = Name();
1988	jj_consume_token(DOT);
1989	} else {
1990	;
1991	}
1992	jj_consume_token(THIS);
1993	{if ("" != null) return new Name(tokenRange(), ret, token.image);}
1994	throw new IllegalStateException ("Missing return statement in function");
1995	}
1996
1997	/**
1998	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.8
1999	* <pre>{@code
2000	* ConstructorDeclaration:
2001	* {ConstructorModifier} ConstructorDeclarator [Throws] ConstructorBody
2002	* ConstructorDeclarator:
2003	* [TypeParameters] SimpleTypeName ( [ReceiverParameter ,] [FormalParameterList] )
2004	* SimpleTypeName:
2005	* TypeIdentifier
2006	* }</pre>
2007	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.8.7
2008	* <pre>{@code
2009	* ConstructorBody:
2010	* { [ExplicitConstructorInvocation] [BlockStatements] }
2011	* }</pre>
2012	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.8.7.1
2013	* <pre>{@code
2014	* ExplicitConstructorInvocation:
2015	* [TypeArguments] this ( [ArgumentList] ) ;
2016	* [TypeArguments] super ( [ArgumentList] ) ;
2017	* ExpressionName . [TypeArguments] super ( [ArgumentList] ) ;
2018	* Primary . [TypeArguments] super ( [ArgumentList] ) ;
2019	* }</pre>
2020	*/
2021	final public ConstructorDeclaration ConstructorDeclaration(ModifierHolder modifier) throws ParseException {RangedList<TypeParameter> typeParameters = new RangedList<TypeParameter>(emptyNodeList());
2022	SimpleName name;
2023	Pair<NodeList<Parameter>, ReceiverParameter> parameters = new Pair<NodeList<Parameter>, ReceiverParameter>(emptyNodeList(), null);
2024	NodeList<ReferenceType> throws_ = emptyNodeList();
2025	ExplicitConstructorInvocationStmt exConsInv = null;
2026	NodeList<Statement> stmts = emptyNodeList();
2027	JavaToken begin = modifier.begin;
2028	JavaToken blockBegin = INVALID;
2029	ReferenceType throwType;
2030	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2031	case LT:{
2032	typeParameters = TypeParameters();
2033	begin = orIfInvalid(begin, typeParameters.range.getBegin());
2034	break;
2035	}
2036	default:
2037	jj_la1[47] = jj_gen;
2038	;
2039	}
2040	// Modifiers matched in the caller
2041	name = SimpleName();
2042	begin = orIfInvalid(begin, typeParameters.range.getBegin()); begin = orIfInvalid(begin, token());
2043	parameters = Parameters();
2044	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2045	case THROWS:{
2046	jj_consume_token(THROWS);
2047	throwType = AnnotatedReferenceType();
2048	throws_ = add(throws_, throwType);
2049	label_20:
2050	while (true) {
2051	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2052	case COMMA:{
2053	break;
2054	}
2055	default:
2056	jj_la1[48] = jj_gen;
2057	break label_20;
2058	}
2059	jj_consume_token(COMMA);
2060	throwType = AnnotatedReferenceType();
2061	throws_ = add(throws_, throwType);
2062	}
2063	break;
2064	}
2065	default:
2066	jj_la1[49] = jj_gen;
2067	;
2068	}
2069	jj_consume_token(LBRACE);
2070	blockBegin=token();
2071	if (jj_2_13(2147483647)) {
2072	exConsInv = ExplicitConstructorInvocation();
2073	} else {
2074	;
2075	}
2076	stmts = Statements();
2077	jj_consume_token(RBRACE);
2078	if (exConsInv != null) {
2079	stmts = prepend(stmts, exConsInv);
2080	}
2081	{if ("" != null) return new ConstructorDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, typeParameters.list, name, parameters.a, throws_, new BlockStmt(range(blockBegin, token()), stmts), parameters.b);}
2082	throw new IllegalStateException ("Missing return statement in function");
2083	}
2084
2085	/**
2086	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.8.7.1
2087	* <pre>{@code
2088	* ExplicitConstructorInvocation:
2089	* [TypeArguments] this ( [ArgumentList] ) ;
2090	* [TypeArguments] super ( [ArgumentList] ) ;
2091	* ExpressionName . [TypeArguments] super ( [ArgumentList] ) ;
2092	* Primary . [TypeArguments] super ( [ArgumentList] ) ;
2093	* }</pre>
2094	* The same, but aligned on {@code super}, to emphasise how this grammar relates:
2095	* <pre>{@code
2096	* ExplicitConstructorInvocation:
2097	* [TypeArguments] this ( [ArgumentList] ) ;
2098	* [TypeArguments] super ( [ArgumentList] ) ;
2099	* ExpressionName . [TypeArguments] super ( [ArgumentList] ) ;
2100	* Primary . [TypeArguments] super ( [ArgumentList] ) ;
2101	* }</pre>
2102	*/
2103	final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocation() throws ParseException {boolean isThis = false;
2104	NodeList<Expression> args;
2105	Expression expr = null;
2106	RangedList<Type> typeArgs = new RangedList<Type>(null);
2107	JavaToken begin = INVALID;
2108	if (jj_2_15(2147483647)) {
2109	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2110	case LT:{
2111	typeArgs = TypeArguments();
2112	begin=typeArgs.range.getBegin();
2113	break;
2114	}
2115	default:
2116	jj_la1[50] = jj_gen;
2117	;
2118	}
2119	jj_consume_token(THIS);
2120	begin = orIfInvalid(begin, token()); isThis = true;
2121	args = Arguments();
2122	jj_consume_token(SEMICOLON);
2123	} else {
2124	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2125	case BOOLEAN:
2126	case BYTE:
2127	case CHAR:
2128	case DOUBLE:
2129	case ENUM:
2130	case FALSE:
2131	case FLOAT:
2132	case INT:
2133	case LONG:
2134	case NEW:
2135	case NULL:
2136	case SHORT:
2137	case STRICTFP:
2138	case SUPER:
2139	case THIS:
2140	case TRUE:
2141	case VOID:
2142	case YIELD:
2143	case REQUIRES:
2144	case TO:
2145	case WITH:
2146	case OPEN:
2147	case OPENS:
2148	case USES:
2149	case MODULE:
2150	case EXPORTS:
2151	case PROVIDES:
2152	case TRANSITIVE:
2153	case LONG_LITERAL:
2154	case INTEGER_LITERAL:
2155	case FLOATING_POINT_LITERAL:
2156	case CHARACTER_LITERAL:
2157	case STRING_LITERAL:
2158	case TEXT_BLOCK_LITERAL:
2159	case IDENTIFIER:
2160	case LPAREN:
2161	case AT:
2162	case LT:{
2163	if (jj_2_14(2147483647)) {
2164	expr = PrimaryExpressionWithoutSuperSuffix();
2165	jj_consume_token(DOT);
2166	begin = orIfInvalid(begin, expr);
2167	} else {
2168	;
2169	}
2170	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2171	case LT:{
2172	typeArgs = TypeArguments();
2173	begin = orIfInvalid(begin, typeArgs.range.getBegin());
2174	break;
2175	}
2176	default:
2177	jj_la1[51] = jj_gen;
2178	;
2179	}
2180	jj_consume_token(SUPER);
2181	begin = orIfInvalid(begin, token());
2182	args = Arguments();
2183	jj_consume_token(SEMICOLON);
2184	break;
2185	}
2186	default:
2187	jj_la1[52] = jj_gen;
2188	jj_consume_token(-1);
2189	throw new ParseException();
2190	}
2191	}
2192	{if ("" != null) return new ExplicitConstructorInvocationStmt(range(begin, token()),typeArgs.list, isThis, expr, args);}
2193	throw new IllegalStateException ("Missing return statement in function");
2194	}
2195
2196	/**
2197	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.5
2198	* <pre>{@code
2199	* Statement:
2200	* StatementWithoutTrailingSubstatement
2201	* LabeledStatement
2202	* IfThenStatement
2203	* IfThenElseStatement
2204	* WhileStatement
2205	* ForStatement
2206	* StatementNoShortIf:
2207	* StatementWithoutTrailingSubstatement
2208	* LabeledStatementNoShortIf
2209	* IfThenElseStatementNoShortIf
2210	* WhileStatementNoShortIf
2211	* ForStatementNoShortIf
2212	* StatementWithoutTrailingSubstatement:
2213	* Block
2214	* EmptyStatement
2215	* ExpressionStatement
2216	* AssertStatement
2217	* SwitchStatement
2218	* DoStatement
2219	* BreakStatement
2220	* ContinueStatement
2221	* ReturnStatement
2222	* SynchronizedStatement
2223	* ThrowStatement
2224	* TryStatement
2225	* YieldStatement
2226	* }</pre>
2227	*/
2228	final public NodeList<Statement> Statements() throws ParseException {NodeList<Statement> ret = emptyNodeList();
2229	Statement stmt;
2230	label_21:
2231	while (true) {
2232	if (jj_2_16(2)) {
2233	} else {
2234	break label_21;
2235	}
2236	stmt = BlockStatement();
2237	ret = add(ret, stmt);
2238	}
2239	{if ("" != null) return ret;}
2240	throw new IllegalStateException ("Missing return statement in function");
2241	}
2242
2243	/**
2244	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.6
2245	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.
2246	* <pre>{@code
2247	* InstanceInitializer:
2248	* Block
2249	* }</pre>
2250	* <pre>{@code
2251	* StaticInitializer:
2252	* static Block
2253	* }</pre>
2254	*/
2255	final public InitializerDeclaration InitializerDeclaration() throws ParseException {BlockStmt body;
2256	JavaToken begin = INVALID;
2257	boolean isStatic = false;
2258	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2259	case STATIC:{
2260	jj_consume_token(STATIC);
2261	isStatic = true; begin=token();
2262	break;
2263	}
2264	default:
2265	jj_la1[53] = jj_gen;
2266	;
2267	}
2268	body = Block();
2269	begin = orIfInvalid(begin, body);
2270	{if ("" != null) return new InitializerDeclaration(range(begin, token()), isStatic, body);}
2271	throw new IllegalStateException ("Missing return statement in function");
2272	}
2273
2274	/*
2275	* Type, name and expression syntax follows.
2276	*/
2277
2278
2279	/**
2280	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.1
2281	* <pre>{@code
2282	* Type:
2283	* PrimitiveType
2284	* ReferenceType
2285	* }<pre>
2286	*/
2287	final public Type Type(NodeList<AnnotationExpr> annotations) throws ParseException {Type ret;
2288	if (jj_2_17(2147483647)) {
2289	ret = ReferenceType(annotations);
2290	} else {
2291	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2292	case BOOLEAN:
2293	case BYTE:
2294	case CHAR:
2295	case DOUBLE:
2296	case FLOAT:
2297	case INT:
2298	case LONG:
2299	case SHORT:{
2300	ret = PrimitiveType(annotations);
2301	break;
2302	}
2303	default:
2304	jj_la1[54] = jj_gen;
2305	jj_consume_token(-1);
2306	throw new ParseException();
2307	}
2308	}
2309	{if ("" != null) return ret;}
2310	throw new IllegalStateException ("Missing return statement in function");
2311	}
2312
2313	/**
2314	* // TODO: JLS Has type and unannotated type, while JavaParser has type and annotated type.
2315	* Note that an array of primitives is considered a reference type.
2316	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.1
2317	* <pre>{@code
2318	* ReferenceType:
2319	* ClassOrInterfaceType
2320	* TypeVariable
2321	* ArrayType
2322	* ClassOrInterfaceType:
2323	* ClassType
2324	* InterfaceType
2325	* ClassType:
2326	* {Annotation} TypeIdentifier [TypeArguments]
2327	* PackageName . {Annotation} TypeIdentifier [TypeArguments]
2328	* ClassOrInterfaceType . {Annotation} TypeIdentifier [TypeArguments]
2329	* InterfaceType:
2330	* ClassType
2331	* TypeVariable:
2332	* {Annotation} TypeIdentifier
2333	* ArrayType:
2334	* PrimitiveType Dims
2335	* ClassOrInterfaceType Dims
2336	* TypeVariable Dims
2337	* Dims:
2338	* {Annotation} [ ] {{Annotation} [ ]}
2339	* }<pre>
2340	*/
2341	final public ReferenceType ReferenceType(NodeList<AnnotationExpr> annotations) throws ParseException {Type type;
2342	ArrayBracketPair arrayBracketPair;
2343	List<ArrayBracketPair> arrayBracketPairs = new ArrayList<ArrayBracketPair>(0);
2344	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2345	case BOOLEAN:
2346	case BYTE:
2347	case CHAR:
2348	case DOUBLE:
2349	case FLOAT:
2350	case INT:
2351	case LONG:
2352	case SHORT:{
2353	// Note that an array of primitives is considered a reference type.
2354	type = PrimitiveType(annotations);
2355	label_22:
2356	while (true) {
2357	arrayBracketPair = ArrayBracketPair(Origin.TYPE);
2358	arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair);
2359	if (jj_2_18(2147483647)) {
2360	} else {
2361	break label_22;
2362	}
2363	}
2364	break;
2365	}
2366	case ENUM:
2367	case STRICTFP:
2368	case YIELD:
2369	case REQUIRES:
2370	case TO:
2371	case WITH:
2372	case OPEN:
2373	case OPENS:
2374	case USES:
2375	case MODULE:
2376	case EXPORTS:
2377	case PROVIDES:
2378	case TRANSITIVE:
2379	case IDENTIFIER:{
2380	type = ClassOrInterfaceType(annotations);
2381	label_23:
2382	while (true) {
2383	if (jj_2_19(2147483647)) {
2384	} else {
2385	break label_23;
2386	}
2387	arrayBracketPair = ArrayBracketPair(Origin.TYPE);
2388	arrayBracketPairs=add(arrayBracketPairs, arrayBracketPair);
2389	}
2390	break;
2391	}
2392	default:
2393	jj_la1[55] = jj_gen;
2394	jj_consume_token(-1);
2395	throw new ParseException();
2396	}
2397	{if ("" != null) return (ReferenceType)wrapInArrayTypes(type, arrayBracketPairs);}
2398	throw new IllegalStateException ("Missing return statement in function");
2399	}
2400
2401	/**
2402	* Array bracket pairs is referred to as {@code Dims} within the JLS.
2403	* <pre>{@code
2404	* Dims:
2405	* {Annotation} [ ] {{Annotation} [ ]}
2406	* }</pre>
2407	*
2408	*/
2409	final public ArrayBracketPair ArrayBracketPair(Origin origin) throws ParseException {NodeList<AnnotationExpr> annotations;
2410	JavaToken begin = INVALID;
2411	annotations = Annotations();
2412	jj_consume_token(LBRACKET);
2413	begin = orIfInvalid(begin, token());
2414	jj_consume_token(RBRACKET);
2415	{if ("" != null) return new ArrayBracketPair(range(begin, token()), origin, annotations);}
2416	throw new IllegalStateException ("Missing return statement in function");
2417	}
2418
2419	/**
2420	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.9
2421	* <blockquote>
2422	* An intersection type takes the form T1 & ... & Tn (n > 0), where Ti (1 ≤ i ≤ n) are types.
2423	* </blockquote>
2424	*/
2425	final public IntersectionType IntersectionType(NodeList<AnnotationExpr> annotations) throws ParseException {JavaToken begin = INVALID;
2426	ReferenceType elementType;
2427	NodeList<ReferenceType> elements = emptyNodeList();
2428	elementType = ReferenceType(annotations);
2429	begin = orIfInvalid(begin, elementType); elements = add(elements, elementType);
2430	jj_consume_token(BIT_AND);
2431	label_24:
2432	while (true) {
2433	elementType = AnnotatedReferenceType();
2434	elements = add(elements, elementType);
2435	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2436	case BOOLEAN:
2437	case BYTE:
2438	case CHAR:
2439	case DOUBLE:
2440	case ENUM:
2441	case FLOAT:
2442	case INT:
2443	case LONG:
2444	case SHORT:
2445	case STRICTFP:
2446	case YIELD:
2447	case REQUIRES:
2448	case TO:
2449	case WITH:
2450	case OPEN:
2451	case OPENS:
2452	case USES:
2453	case MODULE:
2454	case EXPORTS:
2455	case PROVIDES:
2456	case TRANSITIVE:
2457	case IDENTIFIER:
2458	case AT:{
2459	break;
2460	}
2461	default:
2462	jj_la1[56] = jj_gen;
2463	break label_24;
2464	}
2465	}
2466	{if ("" != null) return new IntersectionType(range(begin, token()), elements);}
2467	throw new IllegalStateException ("Missing return statement in function");
2468	}
2469
2470	// TODO: JLS Has type and unannotated type, while JavaParser has type and annotated type.
2471	final public ClassOrInterfaceType AnnotatedClassOrInterfaceType() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
2472	ClassOrInterfaceType cit;
2473	annotations = Annotations();
2474	cit = ClassOrInterfaceType(annotations);
2475	{if ("" != null) return cit;}
2476	throw new IllegalStateException ("Missing return statement in function");
2477	}
2478
2479	// TODO: JLS Has type and unannotated type, while JavaParser has type and annotated type.
2480	final public ClassOrInterfaceType ClassOrInterfaceType(NodeList<AnnotationExpr> firstAnnotations) throws ParseException {ClassOrInterfaceType ret;
2481	SimpleName name;
2482	RangedList<Type> typeArgs = new RangedList<Type>(null);
2483	JavaToken begin;
2484	NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
2485	name = SimpleName();
2486	begin=token();
2487	if (jj_2_20(2)) {
2488	typeArgs = TypeArguments();
2489	} else {
2490	;
2491	}
2492	ret = new ClassOrInterfaceType(range(begin, token()), null, name, typeArgs.list, firstAnnotations);
2493	typeArgs = new RangedList<Type>(null);
2494	label_25:
2495	while (true) {
2496	if (jj_2_21(2)) {
2497	} else {
2498	break label_25;
2499	}
2500	jj_consume_token(DOT);
2501	annotations = Annotations();
2502	name = SimpleName();
2503	if (jj_2_22(2)) {
2504	typeArgs = TypeArguments();
2505	} else {
2506	;
2507	}
2508	ret = new ClassOrInterfaceType(range(begin, token()), ret, name, typeArgs.list, annotations);
2509	typeArgs = new RangedList<Type>(null);
2510	}
2511	{if ("" != null) return ret;}
2512	throw new IllegalStateException ("Missing return statement in function");
2513	}
2514
2515	/**
2516	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.5.1
2517	* <pre>{@code
2518	* TypeArguments:
2519	* < TypeArgumentList >
2520	* TypeArgumentList:
2521	* TypeArgument {, TypeArgument}
2522	* TypeArgument:
2523	* ReferenceType
2524	* Wildcard
2525	* }<pre>
2526	*/
2527	final public RangedList<Type> TypeArguments() throws ParseException {RangedList<Type> ret = new RangedList<Type>(new NodeList<Type>());
2528	Type type;
2529	jj_consume_token(LT);
2530	ret.beginAt(token());
2531	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2532	case BOOLEAN:
2533	case BYTE:
2534	case CHAR:
2535	case DOUBLE:
2536	case ENUM:
2537	case FLOAT:
2538	case INT:
2539	case LONG:
2540	case SHORT:
2541	case STRICTFP:
2542	case YIELD:
2543	case REQUIRES:
2544	case TO:
2545	case WITH:
2546	case OPEN:
2547	case OPENS:
2548	case USES:
2549	case MODULE:
2550	case EXPORTS:
2551	case PROVIDES:
2552	case TRANSITIVE:
2553	case IDENTIFIER:
2554	case AT:
2555	case HOOK:{
2556	type = TypeArgument();
2557	ret.add(type);
2558	label_26:
2559	while (true) {
2560	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2561	case COMMA:{
2562	break;
2563	}
2564	default:
2565	jj_la1[57] = jj_gen;
2566	break label_26;
2567	}
2568	jj_consume_token(COMMA);
2569	type = TypeArgument();
2570	ret.add(type);
2571	}
2572	break;
2573	}
2574	default:
2575	jj_la1[58] = jj_gen;
2576	;
2577	}
2578	jj_consume_token(GT);
2579	ret.endAt(token());
2580	{if ("" != null) return ret;}
2581	throw new IllegalStateException ("Missing return statement in function");
2582	}
2583
2584	/**
2585	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.5.1
2586	* <pre>{@code
2587	* TypeArguments:
2588	* < TypeArgumentList >
2589	* TypeArgumentList:
2590	* TypeArgument {, TypeArgument}
2591	* TypeArgument:
2592	* ReferenceType
2593	* Wildcard
2594	* }<pre>
2595	*/
2596	final public Type TypeArgument() throws ParseException {Type ret;
2597	NodeList<AnnotationExpr> annotations;
2598	annotations = Annotations();
2599	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2600	case BOOLEAN:
2601	case BYTE:
2602	case CHAR:
2603	case DOUBLE:
2604	case ENUM:
2605	case FLOAT:
2606	case INT:
2607	case LONG:
2608	case SHORT:
2609	case STRICTFP:
2610	case YIELD:
2611	case REQUIRES:
2612	case TO:
2613	case WITH:
2614	case OPEN:
2615	case OPENS:
2616	case USES:
2617	case MODULE:
2618	case EXPORTS:
2619	case PROVIDES:
2620	case TRANSITIVE:
2621	case IDENTIFIER:{
2622	ret = Type(annotations);
2623	break;
2624	}
2625	case HOOK:{
2626	ret = Wildcard(annotations);
2627	break;
2628	}
2629	default:
2630	jj_la1[59] = jj_gen;
2631	jj_consume_token(-1);
2632	throw new ParseException();
2633	}
2634	{if ("" != null) return ret;}
2635	throw new IllegalStateException ("Missing return statement in function");
2636	}
2637
2638	/**
2639	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.5.1
2640	* <pre>{@code
2641	* Wildcard:
2642	* {Annotation} ? [WildcardBounds]
2643	* WildcardBounds:
2644	* extends ReferenceType
2645	* super ReferenceType
2646	* }<pre>
2647	*/
2648	final public WildcardType Wildcard(NodeList<AnnotationExpr> firstAnnotations) throws ParseException {ReferenceType ext = null;
2649	ReferenceType sup = null;
2650	JavaToken begin;
2651	NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
2652	jj_consume_token(HOOK);
2653	begin=token();
2654	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2655	case EXTENDS:
2656	case SUPER:{
2657	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2658	case EXTENDS:{
2659	jj_consume_token(EXTENDS);
2660	annotations = Annotations();
2661	ext = ReferenceType(annotations);
2662	break;
2663	}
2664	case SUPER:{
2665	jj_consume_token(SUPER);
2666	annotations = Annotations();
2667	sup = ReferenceType(annotations);
2668	break;
2669	}
2670	default:
2671	jj_la1[60] = jj_gen;
2672	jj_consume_token(-1);
2673	throw new ParseException();
2674	}
2675	break;
2676	}
2677	default:
2678	jj_la1[61] = jj_gen;
2679	;
2680	}
2681	{if ("" != null) return new WildcardType(range(begin, token()), ext, sup, firstAnnotations);}
2682	throw new IllegalStateException ("Missing return statement in function");
2683	}
2684
2685	/**
2686	* Note that {@code char} and {@code byte} are treated as an {@code IntegralType}, which is a subtype of {@code NumericType}.
2687	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-4.html#jls-4.2
2688	* <pre>{@code
2689	* PrimitiveType:
2690	* {Annotation} NumericType
2691	* {Annotation} boolean
2692	* NumericType:
2693	* IntegralType
2694	* FloatingPointType
2695	* IntegralType:
2696	* (one of)
2697	* byte short int long char
2698	* FloatingPointType:
2699	* (one of)
2700	* float double
2701	* }<pre>
2702	*/
2703	final public PrimitiveType PrimitiveType(NodeList<AnnotationExpr> annotations) throws ParseException {PrimitiveType ret;
2704	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2705	case BOOLEAN:{
2706	jj_consume_token(BOOLEAN);
2707	ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.BOOLEAN, annotations);
2708	break;
2709	}
2710	case CHAR:{
2711	jj_consume_token(CHAR);
2712	ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.CHAR, annotations);
2713	break;
2714	}
2715	case BYTE:{
2716	jj_consume_token(BYTE);
2717	ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.BYTE, annotations);
2718	break;
2719	}
2720	case SHORT:{
2721	jj_consume_token(SHORT);
2722	ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.SHORT, annotations);
2723	break;
2724	}
2725	case INT:{
2726	jj_consume_token(INT);
2727	ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.INT, annotations);
2728	break;
2729	}
2730	case LONG:{
2731	jj_consume_token(LONG);
2732	ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.LONG, annotations);
2733	break;
2734	}
2735	case FLOAT:{
2736	jj_consume_token(FLOAT);
2737	ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.FLOAT, annotations);
2738	break;
2739	}
2740	case DOUBLE:{
2741	jj_consume_token(DOUBLE);
2742	ret = new PrimitiveType(tokenRange(), PrimitiveType.Primitive.DOUBLE, annotations);
2743	break;
2744	}
2745	default:
2746	jj_la1[62] = jj_gen;
2747	jj_consume_token(-1);
2748	throw new ParseException();
2749	}
2750	{if ("" != null) return ret;}
2751	throw new IllegalStateException ("Missing return statement in function");
2752	}
2753
2754	/**
2755	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.4.5
2756	* <pre>{@code
2757	* Result:
2758	* UnannType
2759	* void
2760	* }<pre>
2761	*/
2762	final public Type ResultType(NodeList<AnnotationExpr> annotations) throws ParseException {Type ret;
2763	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2764	case VOID:{
2765	jj_consume_token(VOID);
2766	ret = new VoidType(tokenRange());
2767	break;
2768	}
2769	case BOOLEAN:
2770	case BYTE:
2771	case CHAR:
2772	case DOUBLE:
2773	case ENUM:
2774	case FLOAT:
2775	case INT:
2776	case LONG:
2777	case SHORT:
2778	case STRICTFP:
2779	case YIELD:
2780	case REQUIRES:
2781	case TO:
2782	case WITH:
2783	case OPEN:
2784	case OPENS:
2785	case USES:
2786	case MODULE:
2787	case EXPORTS:
2788	case PROVIDES:
2789	case TRANSITIVE:
2790	case IDENTIFIER:{
2791	ret = Type(annotations);
2792	break;
2793	}
2794	default:
2795	jj_la1[63] = jj_gen;
2796	jj_consume_token(-1);
2797	throw new ParseException();
2798	}
2799	{if ("" != null) return ret;}
2800	throw new IllegalStateException ("Missing return statement in function");
2801	}
2802
2803	/**
2804	* A {@code SimpleName} is just an identifier.
2805	* A {@code Name} can be a {@code SimpleName} or a {@code SimpleName} with qualifiers (e.g. a class or object reference).
2806	* Note that no disambiguation is made as to exactly what type of name it is - e.g. whether it is a package, subclass, or field. That happens within JavaParser, rather than the grammar.
2807	*/
2808	final public Name Name() throws ParseException {Name ret;
2809	Identifier();
2810	ret = new Name(tokenRange(), null, token.image);
2811	label_27:
2812	while (true) {
2813	if (jj_2_23(2)) {
2814	} else {
2815	break label_27;
2816	}
2817	jj_consume_token(DOT);
2818	Identifier();
2819	ret = new Name(range(ret, token()), ret, token.image);
2820	}
2821	{if ("" != null) return ret;}
2822	throw new IllegalStateException ("Missing return statement in function");
2823	}
2824
2825	/**
2826	* A {@code SimpleName} is just an identifier.
2827	* A {@code Name} can be a {@code SimpleName} or a {@code SimpleName} with qualifiers (e.g. a class or object reference).
2828	* Note that no disambiguation is made as to exactly what type of name it is - e.g. whether it is a package, subclass, or field. That happens within JavaParser, rather than the grammar.
2829	*/
2830	final public SimpleName SimpleName() throws ParseException {SimpleName ret;
2831	Identifier();
2832	ret = new SimpleName(tokenRange(), token.image);
2833	{if ("" != null) return ret;}
2834	throw new IllegalStateException ("Missing return statement in function");
2835	}
2836
2837	/**
2838	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-3.html#jls-3.8
2839	* <pre>{@code
2840	* Identifier:
2841	* IdentifierChars but not a Keyword or BooleanLiteral or NullLiteral
2842	* IdentifierChars:
2843	* JavaLetter {JavaLetterOrDigit}
2844	* JavaLetter:
2845	* any Unicode character that is a "Java letter"
2846	* }</pre>
2847	* For Convenience:
2848	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-3.html#jls-3.9
2849	* <blockquote>
2850	* 51 character sequences, formed from ASCII letters, are reserved for use as keywords and cannot be used as identifiers (§3.8).
2851	* </blockquote>
2852	* <pre>{@code
2853	* Keyword:
2854	* (one of)
2855	*
2856	* abstract continue for new switch
2857	* assert default if package synchronized
2858	* boolean do goto private this
2859	* break double implements protected throw
2860	* byte else import public throws
2861	* case enum instanceof return transient
2862	* catch extends int short try
2863	* char final interface static void
2864	* class finally long strictfp volatile
2865	* const float native super while
2866	* _ (underscore)
2867	* }</pre>
2868	*/
2869	final public String Identifier() throws ParseException {String ret;
2870	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2871	case MODULE:{
2872	jj_consume_token(MODULE);
2873	break;
2874	}
2875	case REQUIRES:{
2876	jj_consume_token(REQUIRES);
2877	break;
2878	}
2879	case TO:{
2880	jj_consume_token(TO);
2881	break;
2882	}
2883	case WITH:{
2884	jj_consume_token(WITH);
2885	break;
2886	}
2887	case OPEN:{
2888	jj_consume_token(OPEN);
2889	break;
2890	}
2891	case OPENS:{
2892	jj_consume_token(OPENS);
2893	break;
2894	}
2895	case USES:{
2896	jj_consume_token(USES);
2897	break;
2898	}
2899	case EXPORTS:{
2900	jj_consume_token(EXPORTS);
2901	break;
2902	}
2903	case PROVIDES:{
2904	jj_consume_token(PROVIDES);
2905	break;
2906	}
2907	case TRANSITIVE:{
2908	jj_consume_token(TRANSITIVE);
2909	break;
2910	}
2911	case ENUM:{
2912	jj_consume_token(ENUM);
2913	break;
2914	}
2915	case STRICTFP:{
2916	jj_consume_token(STRICTFP);
2917	break;
2918	}
2919	case YIELD:{
2920	jj_consume_token(YIELD);
2921	break;
2922	}
2923	case IDENTIFIER:{
2924	jj_consume_token(IDENTIFIER);
2925	break;
2926	}
2927	default:
2928	jj_la1[64] = jj_gen;
2929	jj_consume_token(-1);
2930	throw new ParseException();
2931	}
2932	ret = token.image; setTokenKind(IDENTIFIER);
2933	{if ("" != null) return ret;}
2934	throw new IllegalStateException ("Missing return statement in function");
2935	}
2936
2937	/*
2938	* Expression syntax follows.
2939	*/
2940	final public
2941
2942	Expression Expression() throws ParseException {Expression ret;
2943	AssignExpr.Operator op;
2944	Expression value;
2945	Statement lambdaBody = null;
2946	RangedList<Type> typeArgs = new RangedList<Type>(null);
2947	ret = ConditionalExpression();
2948	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2949	case ASSIGN:
2950	case ARROW:
2951	case PLUSASSIGN:
2952	case MINUSASSIGN:
2953	case STARASSIGN:
2954	case SLASHASSIGN:
2955	case ANDASSIGN:
2956	case ORASSIGN:
2957	case XORASSIGN:
2958	case REMASSIGN:
2959	case LSHIFTASSIGN:
2960	case RSIGNEDSHIFTASSIGN:
2961	case RUNSIGNEDSHIFTASSIGN:
2962	case DOUBLECOLON:{
2963	if (jj_2_24(2)) {
2964	op = AssignmentOperator();
2965	value = Expression();
2966	ret = new AssignExpr(range(ret, token()), ret, value, op);
2967	} else {
2968	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2969	case ARROW:{
2970	jj_consume_token(ARROW);
2971	lambdaBody = LambdaBody();
2972	if (ret instanceof CastExpr) {
2973	ret = generateLambda(ret, lambdaBody);
2974	} else if (ret instanceof ConditionalExpr) {
2975	ConditionalExpr ce = (ConditionalExpr) ret;
2976	if(ce.getElseExpr() != null) {
2977	ce.setElseExpr(generateLambda(ce.getElseExpr(), lambdaBody));
2978	}
2979	} else {
2980	ret = generateLambda(ret, lambdaBody);
2981	}
2982	break;
2983	}
2984	case DOUBLECOLON:{
2985	jj_consume_token(DOUBLECOLON);
2986	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2987	case LT:{
2988	typeArgs = TypeArguments();
2989	break;
2990	}
2991	default:
2992	jj_la1[65] = jj_gen;
2993	;
2994	}
2995	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
2996	case ENUM:
2997	case STRICTFP:
2998	case YIELD:
2999	case REQUIRES:
3000	case TO:
3001	case WITH:
3002	case OPEN:
3003	case OPENS:
3004	case USES:
3005	case MODULE:
3006	case EXPORTS:
3007	case PROVIDES:
3008	case TRANSITIVE:
3009	case IDENTIFIER:{
3010	Identifier();
3011	break;
3012	}
3013	case NEW:{
3014	jj_consume_token(NEW);
3015	break;
3016	}
3017	default:
3018	jj_la1[66] = jj_gen;
3019	jj_consume_token(-1);
3020	throw new ParseException();
3021	}
3022	ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image);
3023	break;
3024	}
3025	default:
3026	jj_la1[67] = jj_gen;
3027	jj_consume_token(-1);
3028	throw new ParseException();
3029	}
3030	}
3031	break;
3032	}
3033	default:
3034	jj_la1[68] = jj_gen;
3035	;
3036	}
3037	{if ("" != null) return ret;}
3038	throw new IllegalStateException ("Missing return statement in function");
3039	}
3040
3041	/**
3042	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.26
3043	* <pre>{@code
3044	* AssignmentExpression:
3045	* ConditionalExpression
3046	* Assignment
3047	* Assignment:
3048	* LeftHandSide AssignmentOperator Expression
3049	* LeftHandSide:
3050	* ExpressionName
3051	* FieldAccess
3052	* ArrayAccess
3053	* AssignmentOperator:
3054	* (one of)
3055	* = *= /= %= += -= <<= >>= >>>= &= ^= \|=
3056	* }<pre>
3057	*/
3058	final public AssignExpr.Operator AssignmentOperator() throws ParseException {AssignExpr.Operator ret;
3059	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3060	case ASSIGN:{
3061	jj_consume_token(ASSIGN);
3062	ret = AssignExpr.Operator.ASSIGN;
3063	break;
3064	}
3065	case STARASSIGN:{
3066	jj_consume_token(STARASSIGN);
3067	ret = AssignExpr.Operator.MULTIPLY;
3068	break;
3069	}
3070	case SLASHASSIGN:{
3071	jj_consume_token(SLASHASSIGN);
3072	ret = AssignExpr.Operator.DIVIDE;
3073	break;
3074	}
3075	case REMASSIGN:{
3076	jj_consume_token(REMASSIGN);
3077	ret = AssignExpr.Operator.REMAINDER;
3078	break;
3079	}
3080	case PLUSASSIGN:{
3081	jj_consume_token(PLUSASSIGN);
3082	ret = AssignExpr.Operator.PLUS;
3083	break;
3084	}
3085	case MINUSASSIGN:{
3086	jj_consume_token(MINUSASSIGN);
3087	ret = AssignExpr.Operator.MINUS;
3088	break;
3089	}
3090	case LSHIFTASSIGN:{
3091	jj_consume_token(LSHIFTASSIGN);
3092	ret = AssignExpr.Operator.LEFT_SHIFT;
3093	break;
3094	}
3095	case RSIGNEDSHIFTASSIGN:{
3096	jj_consume_token(RSIGNEDSHIFTASSIGN);
3097	ret = AssignExpr.Operator.SIGNED_RIGHT_SHIFT;
3098	break;
3099	}
3100	case RUNSIGNEDSHIFTASSIGN:{
3101	jj_consume_token(RUNSIGNEDSHIFTASSIGN);
3102	ret = AssignExpr.Operator.UNSIGNED_RIGHT_SHIFT;
3103	break;
3104	}
3105	case ANDASSIGN:{
3106	jj_consume_token(ANDASSIGN);
3107	ret = AssignExpr.Operator.BINARY_AND;
3108	break;
3109	}
3110	case XORASSIGN:{
3111	jj_consume_token(XORASSIGN);
3112	ret = AssignExpr.Operator.XOR;
3113	break;
3114	}
3115	case ORASSIGN:{
3116	jj_consume_token(ORASSIGN);
3117	ret = AssignExpr.Operator.BINARY_OR;
3118	break;
3119	}
3120	default:
3121	jj_la1[69] = jj_gen;
3122	jj_consume_token(-1);
3123	throw new ParseException();
3124	}
3125	{if ("" != null) return ret;}
3126	throw new IllegalStateException ("Missing return statement in function");
3127	}
3128
3129	/**
3130	* // TODO: Examine further re: missing(?) {@code LambdaExpression} or whether it is permissive enough to include it.
3131	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.25
3132	* <pre>{@code
3133	* ConditionalExpression:
3134	* ConditionalOrExpression
3135	* ConditionalOrExpression ? Expression : ConditionalExpression
3136	* ConditionalOrExpression ? Expression : LambdaExpression
3137	* }<pre>
3138	*/
3139	final public Expression ConditionalExpression() throws ParseException {Expression ret;
3140	Expression left;
3141	Expression right;
3142	ret = ConditionalOrExpression();
3143	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3144	case HOOK:{
3145	jj_consume_token(HOOK);
3146	left = Expression();
3147	jj_consume_token(COLON);
3148	right = ConditionalExpression();
3149	ret = new ConditionalExpr(range(ret, token()), ret, left, right);
3150	break;
3151	}
3152	default:
3153	jj_la1[70] = jj_gen;
3154	;
3155	}
3156	{if ("" != null) return ret;}
3157	throw new IllegalStateException ("Missing return statement in function");
3158	}
3159
3160	/**
3161	* <strong>
3162	* Note subtle distinctions between inclusive and exclusive expressions.
3163	* </strong>
3164	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.24
3165	* <pre>{@code
3166	* ConditionalOrExpression:
3167	* ConditionalAndExpression
3168	* ConditionalOrExpression \|\| ConditionalAndExpression
3169	* }<pre>
3170	*/
3171	final public Expression ConditionalOrExpression() throws ParseException {Expression ret;
3172	Expression right;
3173	// First consider a higher-precedence operator, before considering the token as the left-hand part of this expression.
3174	ret = ConditionalAndExpression();
3175	label_28:
3176	while (true) {
3177	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3178	case SC_OR:{
3179	break;
3180	}
3181	default:
3182	jj_la1[71] = jj_gen;
3183	break label_28;
3184	}
3185	jj_consume_token(SC_OR);
3186	right = ConditionalAndExpression();
3187	ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.OR);
3188	}
3189	{if ("" != null) return ret;}
3190	throw new IllegalStateException ("Missing return statement in function");
3191	}
3192
3193	/**
3194	* <strong>
3195	* Note subtle distinctions between inclusive and exclusive expressions.
3196	* </strong>
3197	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.23
3198	* <pre>{@code
3199	* ConditionalAndExpression:
3200	* InclusiveOrExpression
3201	* ConditionalAndExpression && InclusiveOrExpression
3202	* }<pre>
3203	* For Convenience:
3204	* <pre>{@code
3205	* AndExpression:
3206	* EqualityExpression
3207	* AndExpression & EqualityExpression
3208	* ExclusiveOrExpression:
3209	* AndExpression
3210	* ExclusiveOrExpression ^ AndExpression
3211	* InclusiveOrExpression:
3212	* ExclusiveOrExpression
3213	* InclusiveOrExpression \| ExclusiveOrExpression
3214	* }<pre>
3215	*/
3216	final public Expression ConditionalAndExpression() throws ParseException {Expression ret;
3217	Expression right;
3218	// First consider a higher-precedence operator, before considering the token as the left-hand part of this expression.
3219	ret = InclusiveOrExpression();
3220	label_29:
3221	while (true) {
3222	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3223	case SC_AND:{
3224	break;
3225	}
3226	default:
3227	jj_la1[72] = jj_gen;
3228	break label_29;
3229	}
3230	jj_consume_token(SC_AND);
3231	right = InclusiveOrExpression();
3232	ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.AND);
3233	}
3234	{if ("" != null) return ret;}
3235	throw new IllegalStateException ("Missing return statement in function");
3236	}
3237
3238	/**
3239	* <strong>
3240	* Note subtle distinctions between inclusive and exclusive expressions.
3241	* </strong>
3242	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.22
3243	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-InclusiveOrExpression
3244	* <pre>{@code
3245	* AndExpression:
3246	* EqualityExpression
3247	* AndExpression & EqualityExpression
3248	* ExclusiveOrExpression:
3249	* AndExpression
3250	* ExclusiveOrExpression ^ AndExpression
3251	* InclusiveOrExpression:
3252	* ExclusiveOrExpression
3253	* InclusiveOrExpression \| ExclusiveOrExpression
3254	* }<pre>
3255	*/
3256	final public Expression InclusiveOrExpression() throws ParseException {Expression ret;
3257	Expression right;
3258	// First consider a higher-precedence operator, before considering the token as the left-hand part of this expression.
3259	ret = ExclusiveOrExpression();
3260	label_30:
3261	while (true) {
3262	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3263	case BIT_OR:{
3264	break;
3265	}
3266	default:
3267	jj_la1[73] = jj_gen;
3268	break label_30;
3269	}
3270	jj_consume_token(BIT_OR);
3271	right = ExclusiveOrExpression();
3272	ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.BINARY_OR);
3273	}
3274	{if ("" != null) return ret;}
3275	throw new IllegalStateException ("Missing return statement in function");
3276	}
3277
3278	/**
3279	* <strong>
3280	* Note subtle distinctions between inclusive and exclusive expressions.
3281	* </strong>
3282	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.22
3283	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-ExclusiveOrExpression
3284	* <pre>{@code
3285	* AndExpression:
3286	* EqualityExpression
3287	* AndExpression & EqualityExpression
3288	* ExclusiveOrExpression:
3289	* AndExpression
3290	* ExclusiveOrExpression ^ AndExpression
3291	* InclusiveOrExpression:
3292	* ExclusiveOrExpression
3293	* InclusiveOrExpression \| ExclusiveOrExpression
3294	* }<pre>
3295	*/
3296	final public Expression ExclusiveOrExpression() throws ParseException {Expression ret;
3297	Expression right;
3298	// First consider a higher-precedence operator, before considering the token as the left-hand part of this expression.
3299	ret = AndExpression();
3300	label_31:
3301	while (true) {
3302	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3303	case XOR:{
3304	break;
3305	}
3306	default:
3307	jj_la1[74] = jj_gen;
3308	break label_31;
3309	}
3310	jj_consume_token(XOR);
3311	right = AndExpression();
3312	ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.XOR);
3313	}
3314	{if ("" != null) return ret;}
3315	throw new IllegalStateException ("Missing return statement in function");
3316	}
3317
3318	/**
3319	* <strong>
3320	* Note subtle distinctions between inclusive and exclusive expressions.
3321	* </strong>
3322	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.22
3323	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-AndExpression
3324	* <pre>{@code
3325	* AndExpression:
3326	* EqualityExpression
3327	* AndExpression & EqualityExpression
3328	* ExclusiveOrExpression:
3329	* AndExpression
3330	* ExclusiveOrExpression ^ AndExpression
3331	* InclusiveOrExpression:
3332	* ExclusiveOrExpression
3333	* InclusiveOrExpression \| ExclusiveOrExpression
3334	* }<pre>
3335	*/
3336	final public Expression AndExpression() throws ParseException {Expression ret;
3337	Expression right;
3338	// First consider a higher-precedence operator, before considering the token as the left-hand part of this expression.
3339	ret = EqualityExpression();
3340	label_32:
3341	while (true) {
3342	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3343	case BIT_AND:{
3344	break;
3345	}
3346	default:
3347	jj_la1[75] = jj_gen;
3348	break label_32;
3349	}
3350	jj_consume_token(BIT_AND);
3351	right = EqualityExpression();
3352	ret = new BinaryExpr(range(ret, token()), ret, right, BinaryExpr.Operator.BINARY_AND);
3353	}
3354	{if ("" != null) return ret;}
3355	throw new IllegalStateException ("Missing return statement in function");
3356	}
3357
3358	/**
3359	* // Note that instanceof is a {@code RelationalExpression} within the JLS, which differs from JavaParser
3360	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.21
3361	* <pre>{@code
3362	* EqualityExpression:
3363	* RelationalExpression
3364	* EqualityExpression == RelationalExpression
3365	* EqualityExpression != RelationalExpression
3366	* }<pre>
3367	* For Convenience:
3368	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.20
3369	* <pre>{@code
3370	* RelationalExpression:
3371	* ShiftExpression
3372	* RelationalExpression < ShiftExpression
3373	* RelationalExpression > ShiftExpression
3374	* RelationalExpression <= ShiftExpression
3375	* RelationalExpression >= ShiftExpression
3376	* RelationalExpression instanceof ReferenceType
3377	* }<pre>
3378	*/
3379	final public Expression EqualityExpression() throws ParseException {Expression ret;
3380	Expression right;
3381	BinaryExpr.Operator op;
3382	// First consider a higher-precedence operator, before considering the token as the left-hand part of this expression.
3383	// Note that instanceof is a {@code RelationalExpression} within the JLS, which differs from JavaParser
3384	ret = InstanceOfExpression();
3385	label_33:
3386	while (true) {
3387	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3388	case EQ:
3389	case NE:{
3390	break;
3391	}
3392	default:
3393	jj_la1[76] = jj_gen;
3394	break label_33;
3395	}
3396	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3397	case EQ:{
3398	jj_consume_token(EQ);
3399	op = BinaryExpr.Operator.EQUALS;
3400	break;
3401	}
3402	case NE:{
3403	jj_consume_token(NE);
3404	op = BinaryExpr.Operator.NOT_EQUALS;
3405	break;
3406	}
3407	default:
3408	jj_la1[77] = jj_gen;
3409	jj_consume_token(-1);
3410	throw new ParseException();
3411	}
3412	right = InstanceOfExpression();
3413	ret = new BinaryExpr(range(ret, token()), ret, right, op);
3414	}
3415	{if ("" != null) return ret;}
3416	throw new IllegalStateException ("Missing return statement in function");
3417	}
3418
3419	/**
3420	* // Note that instanceof is a {@code RelationalExpression} within the JLS, which differs from JavaParser
3421	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.20
3422	* <pre>{@code
3423	* RelationalExpression:
3424	* ShiftExpression
3425	* RelationalExpression < ShiftExpression
3426	* RelationalExpression > ShiftExpression
3427	* RelationalExpression <= ShiftExpression
3428	* RelationalExpression >= ShiftExpression
3429	* RelationalExpression instanceof ReferenceType
3430	* }<pre>
3431	*/
3432	final public Expression InstanceOfExpression() throws ParseException {Expression ret;
3433	ReferenceType type;
3434	NodeList<AnnotationExpr> annotations;
3435	ret = RelationalExpression();
3436	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3437	case INSTANCEOF:{
3438	jj_consume_token(INSTANCEOF);
3439	type = AnnotatedReferenceType();
3440	ret = new InstanceOfExpr(range(ret, token()), ret, type);
3441	break;
3442	}
3443	default:
3444	jj_la1[78] = jj_gen;
3445	;
3446	}
3447	{if ("" != null) return ret;}
3448	throw new IllegalStateException ("Missing return statement in function");
3449	}
3450
3451	/**
3452	* // Note that instanceof is a {@code RelationalExpression} within the JLS, which differs from JavaParser
3453	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.20
3454	* <pre>{@code
3455	* RelationalExpression:
3456	* ShiftExpression
3457	* RelationalExpression < ShiftExpression
3458	* RelationalExpression > ShiftExpression
3459	* RelationalExpression <= ShiftExpression
3460	* RelationalExpression >= ShiftExpression
3461	* RelationalExpression instanceof ReferenceType
3462	* }<pre>
3463	*/
3464	final public Expression RelationalExpression() throws ParseException {Expression ret;
3465	Expression right;
3466	BinaryExpr.Operator op;
3467	ret = ShiftExpression();
3468	label_34:
3469	while (true) {
3470	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3471	case LT:
3472	case GE:
3473	case LE:
3474	case GT:{
3475	break;
3476	}
3477	default:
3478	jj_la1[79] = jj_gen;
3479	break label_34;
3480	}
3481	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3482	case LT:{
3483	jj_consume_token(LT);
3484	op = BinaryExpr.Operator.LESS;
3485	break;
3486	}
3487	case GT:{
3488	jj_consume_token(GT);
3489	op = BinaryExpr.Operator.GREATER;
3490	break;
3491	}
3492	case LE:{
3493	jj_consume_token(LE);
3494	op = BinaryExpr.Operator.LESS_EQUALS;
3495	break;
3496	}
3497	case GE:{
3498	jj_consume_token(GE);
3499	op = BinaryExpr.Operator.GREATER_EQUALS;
3500	break;
3501	}
3502	default:
3503	jj_la1[80] = jj_gen;
3504	jj_consume_token(-1);
3505	throw new ParseException();
3506	}
3507	right = ShiftExpression();
3508	ret = new BinaryExpr(range(ret, token()), ret, right, op);
3509	}
3510	{if ("" != null) return ret;}
3511	throw new IllegalStateException ("Missing return statement in function");
3512	}
3513
3514	/**
3515	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.19
3516	* <pre>{@code
3517	* ShiftExpression:
3518	* AdditiveExpression
3519	* ShiftExpression << AdditiveExpression
3520	* ShiftExpression >> AdditiveExpression
3521	* ShiftExpression >>> AdditiveExpression
3522	* }<pre>
3523	*/
3524	final public Expression ShiftExpression() throws ParseException {Expression ret;
3525	Expression right;
3526	BinaryExpr.Operator op;
3527	ret = AdditiveExpression();
3528	label_35:
3529	while (true) {
3530	if (jj_2_25(1)) {
3531	} else {
3532	break label_35;
3533	}
3534	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3535	case LSHIFT:{
3536	jj_consume_token(LSHIFT);
3537	op = BinaryExpr.Operator.LEFT_SHIFT;
3538	break;
3539	}
3540	default:
3541	jj_la1[81] = jj_gen;
3542	if (jj_2_26(1)) {
3543	RSIGNEDSHIFT();
3544	op = BinaryExpr.Operator.SIGNED_RIGHT_SHIFT;
3545	} else if (jj_2_27(1)) {
3546	RUNSIGNEDSHIFT();
3547	op = BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT;
3548	} else {
3549	jj_consume_token(-1);
3550	throw new ParseException();
3551	}
3552	}
3553	right = AdditiveExpression();
3554	ret = new BinaryExpr(range(ret, token()), ret, right, op);
3555	}
3556	{if ("" != null) return ret;}
3557	throw new IllegalStateException ("Missing return statement in function");
3558	}
3559
3560	/**
3561	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.18
3562	* <pre>{@code
3563	* AdditiveExpression:
3564	* MultiplicativeExpression
3565	* AdditiveExpression + MultiplicativeExpression
3566	* AdditiveExpression - MultiplicativeExpression
3567	* }<pre>
3568	*/
3569	final public Expression AdditiveExpression() throws ParseException {Expression ret;
3570	Expression right;
3571	BinaryExpr.Operator op;
3572	ret = MultiplicativeExpression();
3573	label_36:
3574	while (true) {
3575	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3576	case PLUS:
3577	case MINUS:{
3578	break;
3579	}
3580	default:
3581	jj_la1[82] = jj_gen;
3582	break label_36;
3583	}
3584	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3585	case PLUS:{
3586	jj_consume_token(PLUS);
3587	op = BinaryExpr.Operator.PLUS;
3588	break;
3589	}
3590	case MINUS:{
3591	jj_consume_token(MINUS);
3592	op = BinaryExpr.Operator.MINUS;
3593	break;
3594	}
3595	default:
3596	jj_la1[83] = jj_gen;
3597	jj_consume_token(-1);
3598	throw new ParseException();
3599	}
3600	right = MultiplicativeExpression();
3601	ret = new BinaryExpr(range(ret, token()), ret, right, op);
3602	}
3603	{if ("" != null) return ret;}
3604	throw new IllegalStateException ("Missing return statement in function");
3605	}
3606
3607	/**
3608	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.17
3609	* <pre>{@code
3610	* MultiplicativeExpression:
3611	* UnaryExpression
3612	* MultiplicativeExpression * UnaryExpression
3613	* MultiplicativeExpression / UnaryExpression
3614	* MultiplicativeExpression % UnaryExpression
3615	* }<pre>
3616	*/
3617	final public Expression MultiplicativeExpression() throws ParseException {Expression ret;
3618	Expression right;
3619	BinaryExpr.Operator op;
3620	ret = UnaryExpression();
3621	label_37:
3622	while (true) {
3623	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3624	case STAR:
3625	case SLASH:
3626	case REM:{
3627	break;
3628	}
3629	default:
3630	jj_la1[84] = jj_gen;
3631	break label_37;
3632	}
3633	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3634	case STAR:{
3635	jj_consume_token(STAR);
3636	op = BinaryExpr.Operator.MULTIPLY;
3637	break;
3638	}
3639	case SLASH:{
3640	jj_consume_token(SLASH);
3641	op = BinaryExpr.Operator.DIVIDE;
3642	break;
3643	}
3644	case REM:{
3645	jj_consume_token(REM);
3646	op = BinaryExpr.Operator.REMAINDER;
3647	break;
3648	}
3649	default:
3650	jj_la1[85] = jj_gen;
3651	jj_consume_token(-1);
3652	throw new ParseException();
3653	}
3654	right = UnaryExpression();
3655	ret = new BinaryExpr(range(ret, token()), ret, right, op);
3656	}
3657	{if ("" != null) return ret;}
3658	throw new IllegalStateException ("Missing return statement in function");
3659	}
3660
3661	/**
3662	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.15
3663	* <pre>{@code
3664	* UnaryExpression:
3665	* PreIncrementExpression
3666	* PreDecrementExpression
3667	* + UnaryExpression
3668	* - UnaryExpression
3669	* UnaryExpressionNotPlusMinus
3670	* PreIncrementExpression:
3671	* ++ UnaryExpression
3672	* PreDecrementExpression:
3673	* -- UnaryExpression
3674	* UnaryExpressionNotPlusMinus:
3675	* PostfixExpression
3676	* ~ UnaryExpression
3677	* ! UnaryExpression
3678	* CastExpression
3679	* SwitchExpression
3680	* }<pre>
3681	*/
3682	final public Expression UnaryExpression() throws ParseException {Expression ret;
3683	UnaryExpr.Operator op;
3684	JavaToken begin = INVALID;
3685	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3686	case INCR:{
3687	ret = PreIncrementExpression();
3688	break;
3689	}
3690	case DECR:{
3691	ret = PreDecrementExpression();
3692	break;
3693	}
3694	case PLUS:
3695	case MINUS:{
3696	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3697	case PLUS:{
3698	jj_consume_token(PLUS);
3699	op = UnaryExpr.Operator.PLUS; begin=token();
3700	break;
3701	}
3702	case MINUS:{
3703	jj_consume_token(MINUS);
3704	op = UnaryExpr.Operator.MINUS; begin=token();
3705	break;
3706	}
3707	default:
3708	jj_la1[86] = jj_gen;
3709	jj_consume_token(-1);
3710	throw new ParseException();
3711	}
3712	ret = UnaryExpression();
3713	ret = new UnaryExpr(range(begin, token()), ret, op);
3714	break;
3715	}
3716	case BOOLEAN:
3717	case BYTE:
3718	case CHAR:
3719	case DOUBLE:
3720	case ENUM:
3721	case FALSE:
3722	case FLOAT:
3723	case INT:
3724	case LONG:
3725	case NEW:
3726	case NULL:
3727	case SHORT:
3728	case STRICTFP:
3729	case SUPER:
3730	case SWITCH:
3731	case THIS:
3732	case TRUE:
3733	case VOID:
3734	case YIELD:
3735	case REQUIRES:
3736	case TO:
3737	case WITH:
3738	case OPEN:
3739	case OPENS:
3740	case USES:
3741	case MODULE:
3742	case EXPORTS:
3743	case PROVIDES:
3744	case TRANSITIVE:
3745	case LONG_LITERAL:
3746	case INTEGER_LITERAL:
3747	case FLOATING_POINT_LITERAL:
3748	case CHARACTER_LITERAL:
3749	case STRING_LITERAL:
3750	case TEXT_BLOCK_LITERAL:
3751	case IDENTIFIER:
3752	case LPAREN:
3753	case AT:
3754	case BANG:
3755	case TILDE:{
3756	ret = UnaryExpressionNotPlusMinus();
3757	break;
3758	}
3759	default:
3760	jj_la1[87] = jj_gen;
3761	jj_consume_token(-1);
3762	throw new ParseException();
3763	}
3764	{if ("" != null) return ret;}
3765	throw new IllegalStateException ("Missing return statement in function");
3766	}
3767
3768	/**
3769	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.15
3770	* <pre>{@code
3771	* PreIncrementExpression:
3772	* ++ UnaryExpression
3773	* }<pre>
3774	*/
3775	final public Expression PreIncrementExpression() throws ParseException {Expression ret;
3776	JavaToken begin = INVALID;
3777	jj_consume_token(INCR);
3778	begin=token();
3779	ret = UnaryExpression();
3780	ret = new UnaryExpr(range(begin, token()), ret, UnaryExpr.Operator.PREFIX_INCREMENT);
3781	{if ("" != null) return ret;}
3782	throw new IllegalStateException ("Missing return statement in function");
3783	}
3784
3785	/**
3786	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.15
3787	* <pre>{@code
3788	* PreDecrementExpression:
3789	* -- UnaryExpression
3790	* }<pre>
3791	*/
3792	final public Expression PreDecrementExpression() throws ParseException {Expression ret;
3793	JavaToken begin;
3794	jj_consume_token(DECR);
3795	begin=token();
3796	ret = UnaryExpression();
3797	ret = new UnaryExpr(range(begin, token()), ret, UnaryExpr.Operator.PREFIX_DECREMENT);
3798	{if ("" != null) return ret;}
3799	throw new IllegalStateException ("Missing return statement in function");
3800	}
3801
3802	/**
3803	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.15
3804	* <pre>{@code
3805	* UnaryExpressionNotPlusMinus:
3806	* PostfixExpression
3807	* ~ UnaryExpression
3808	* ! UnaryExpression
3809	* CastExpression
3810	* SwitchExpression
3811	* }<pre>
3812	*/
3813	final public Expression UnaryExpressionNotPlusMinus() throws ParseException {Expression ret;
3814	UnaryExpr.Operator op;
3815	JavaToken begin = INVALID;
3816	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3817	case BANG:
3818	case TILDE:{
3819	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3820	case TILDE:{
3821	jj_consume_token(TILDE);
3822	op = UnaryExpr.Operator.BITWISE_COMPLEMENT; begin=token();
3823	break;
3824	}
3825	case BANG:{
3826	jj_consume_token(BANG);
3827	op = UnaryExpr.Operator.LOGICAL_COMPLEMENT; begin=token();
3828	break;
3829	}
3830	default:
3831	jj_la1[88] = jj_gen;
3832	jj_consume_token(-1);
3833	throw new ParseException();
3834	}
3835	ret = UnaryExpression();
3836	ret = new UnaryExpr(range(begin, token()), ret, op);
3837	break;
3838	}
3839	default:
3840	jj_la1[89] = jj_gen;
3841	if (jj_2_28(2147483647)) {
3842	ret = CastExpression();
3843	} else {
3844	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3845	case BOOLEAN:
3846	case BYTE:
3847	case CHAR:
3848	case DOUBLE:
3849	case ENUM:
3850	case FALSE:
3851	case FLOAT:
3852	case INT:
3853	case LONG:
3854	case NEW:
3855	case NULL:
3856	case SHORT:
3857	case STRICTFP:
3858	case SUPER:
3859	case THIS:
3860	case TRUE:
3861	case VOID:
3862	case YIELD:
3863	case REQUIRES:
3864	case TO:
3865	case WITH:
3866	case OPEN:
3867	case OPENS:
3868	case USES:
3869	case MODULE:
3870	case EXPORTS:
3871	case PROVIDES:
3872	case TRANSITIVE:
3873	case LONG_LITERAL:
3874	case INTEGER_LITERAL:
3875	case FLOATING_POINT_LITERAL:
3876	case CHARACTER_LITERAL:
3877	case STRING_LITERAL:
3878	case TEXT_BLOCK_LITERAL:
3879	case IDENTIFIER:
3880	case LPAREN:
3881	case AT:{
3882	ret = PostfixExpression();
3883	break;
3884	}
3885	case SWITCH:{
3886	ret = SwitchExpression();
3887	break;
3888	}
3889	default:
3890	jj_la1[90] = jj_gen;
3891	jj_consume_token(-1);
3892	throw new ParseException();
3893	}
3894	}
3895	}
3896	{if ("" != null) return ret;}
3897	throw new IllegalStateException ("Missing return statement in function");
3898	}
3899
3900	/**
3901	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.15
3902	* <pre>{@code
3903	* PostfixExpression:
3904	* Primary
3905	* ExpressionName
3906	* PostIncrementExpression
3907	* PostDecrementExpression
3908	* }<pre>
3909	*/
3910	final public Expression PostfixExpression() throws ParseException {Expression ret;
3911	UnaryExpr.Operator op;
3912	ret = PrimaryExpression();
3913	if (jj_2_29(2)) {
3914	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3915	case INCR:{
3916	jj_consume_token(INCR);
3917	op = UnaryExpr.Operator.POSTFIX_INCREMENT;
3918	break;
3919	}
3920	case DECR:{
3921	jj_consume_token(DECR);
3922	op = UnaryExpr.Operator.POSTFIX_DECREMENT;
3923	break;
3924	}
3925	default:
3926	jj_la1[91] = jj_gen;
3927	jj_consume_token(-1);
3928	throw new ParseException();
3929	}
3930	ret = new UnaryExpr(range(ret, token()), ret, op);
3931	} else {
3932	;
3933	}
3934	{if ("" != null) return ret;}
3935	throw new IllegalStateException ("Missing return statement in function");
3936	}
3937
3938	/**
3939	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.16
3940	* <pre>{@code
3941	* CastExpression:
3942	* ( PrimitiveType ) UnaryExpression
3943	* ( ReferenceType {AdditionalBound} ) UnaryExpressionNotPlusMinus
3944	* ( ReferenceType {AdditionalBound} ) LambdaExpression
3945	* }<pre>
3946	* For Convenience:
3947	* <pre>{@code
3948	* AdditionalBound:
3949	* & InterfaceType
3950	* }<pre>
3951	*/
3952	final public Expression CastExpression() throws ParseException {Expression ret;
3953	ReferenceType referenceType;
3954	PrimitiveType primitiveType;
3955	JavaToken begin = INVALID;
3956	NodeList<AnnotationExpr> annotations;
3957	NodeList<ReferenceType> typesOfMultiCast = emptyNodeList();
3958	jj_consume_token(LPAREN);
3959	begin=token();
3960	annotations = Annotations();
3961	if (jj_2_30(2)) {
3962	primitiveType = PrimitiveType(annotations);
3963	jj_consume_token(RPAREN);
3964	ret = UnaryExpression();
3965	ret = new CastExpr(range(begin, token()), primitiveType, ret);
3966	} else {
3967	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3968	case BOOLEAN:
3969	case BYTE:
3970	case CHAR:
3971	case DOUBLE:
3972	case ENUM:
3973	case FLOAT:
3974	case INT:
3975	case LONG:
3976	case SHORT:
3977	case STRICTFP:
3978	case YIELD:
3979	case REQUIRES:
3980	case TO:
3981	case WITH:
3982	case OPEN:
3983	case OPENS:
3984	case USES:
3985	case MODULE:
3986	case EXPORTS:
3987	case PROVIDES:
3988	case TRANSITIVE:
3989	case IDENTIFIER:{
3990	// ( ReferenceType {AdditionalBound} ) UnaryExpressionNotPlusMinus
3991	// ( ReferenceType {AdditionalBound} ) LambdaExpression
3992	referenceType = ReferenceType(annotations);
3993	typesOfMultiCast = add(typesOfMultiCast, referenceType);
3994	label_38:
3995	while (true) {
3996	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
3997	case BIT_AND:{
3998	break;
3999	}
4000	default:
4001	jj_la1[92] = jj_gen;
4002	break label_38;
4003	}
4004	jj_consume_token(BIT_AND);
4005	referenceType = AnnotatedReferenceType();
4006	typesOfMultiCast = add(typesOfMultiCast, referenceType);
4007	}
4008	jj_consume_token(RPAREN);
4009	ret = UnaryExpressionNotPlusMinus();
4010	if (typesOfMultiCast.size() > 1) {
4011	ret = new CastExpr(range(begin, token()), new IntersectionType(range(typesOfMultiCast.get(0), typesOfMultiCast.get(typesOfMultiCast.size() -1)), typesOfMultiCast), ret);
4012	} else {
4013	ret = new CastExpr(range(begin, token()), referenceType, ret);
4014	}
4015	break;
4016	}
4017	default:
4018	jj_la1[93] = jj_gen;
4019	jj_consume_token(-1);
4020	throw new ParseException();
4021	}
4022	}
4023	{if ("" != null) return ret;}
4024	throw new IllegalStateException ("Missing return statement in function");
4025	}
4026
4027	/**
4028	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.8
4029	* <pre>{@code
4030	* Primary:
4031	* PrimaryNoNewArray
4032	* ArrayCreationExpression
4033	* PrimaryNoNewArray:
4034	* Literal
4035	* ClassLiteral
4036	* this
4037	* TypeName . this
4038	* ( Expression )
4039	* ClassInstanceCreationExpression
4040	* FieldAccess
4041	* ArrayAccess
4042	* MethodInvocation
4043	* MethodReference
4044	* }<pre>
4045	*/
4046	final public Expression PrimaryExpression() throws ParseException {Expression ret;
4047	ret = PrimaryPrefix();
4048	label_39:
4049	while (true) {
4050	if (jj_2_31(2)) {
4051	} else {
4052	break label_39;
4053	}
4054	ret = PrimarySuffix(ret);
4055	}
4056	{if ("" != null) return ret;}
4057	throw new IllegalStateException ("Missing return statement in function");
4058	}
4059
4060	/**
4061	* // TODO: Unclear exactly which part of the JLS this relates to - a JavaParser-specific thing with no 1:1 mapping, perhaps?
4062	*/
4063	final public Expression PrimaryExpressionWithoutSuperSuffix() throws ParseException {Expression ret;
4064	ret = PrimaryPrefix();
4065	label_40:
4066	while (true) {
4067	if (jj_2_32(2147483647)) {
4068	} else {
4069	break label_40;
4070	}
4071	ret = PrimarySuffixWithoutSuper(ret);
4072	}
4073	{if ("" != null) return ret;}
4074	throw new IllegalStateException ("Missing return statement in function");
4075	}
4076
4077	/**
4078	* // TODO: Unclear exactly which part of the JLS this relates to - a JavaParser-specific thing with no 1:1 mapping, perhaps?
4079	*/
4080	final public Expression PrimaryPrefix() throws ParseException {Expression ret = null;
4081	SimpleName name;
4082	RangedList<Type> typeArgs = new RangedList<Type>(null);
4083	NodeList<Expression> args = emptyNodeList();
4084	NodeList<Parameter> params = emptyNodeList();
4085	boolean hasArgs = false;
4086	boolean isLambda = false;
4087	Type type;
4088	JavaToken begin;
4089	Parameter p = null;
4090	SimpleName id = null;
4091	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4092	case FALSE:
4093	case NULL:
4094	case TRUE:
4095	case LONG_LITERAL:
4096	case INTEGER_LITERAL:
4097	case FLOATING_POINT_LITERAL:
4098	case CHARACTER_LITERAL:
4099	case STRING_LITERAL:
4100	case TEXT_BLOCK_LITERAL:{
4101	ret = Literal();
4102	break;
4103	}
4104	case THIS:{
4105	jj_consume_token(THIS);
4106	ret = new ThisExpr(tokenRange(), null);
4107	break;
4108	}
4109	case SUPER:{
4110	jj_consume_token(SUPER);
4111	ret = new SuperExpr(tokenRange(), null);
4112	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4113	case DOT:{
4114	jj_consume_token(DOT);
4115	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4116	case LT:{
4117	typeArgs = TypeArguments();
4118	break;
4119	}
4120	default:
4121	jj_la1[94] = jj_gen;
4122	;
4123	}
4124	name = SimpleName();
4125	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4126	case LPAREN:{
4127	args = Arguments();
4128	hasArgs=true;
4129	break;
4130	}
4131	default:
4132	jj_la1[95] = jj_gen;
4133	;
4134	}
4135	if (hasArgs) {
4136	ret = new MethodCallExpr(range(ret, token()), ret, typeArgs.list, name, args);
4137	} else {
4138	ret = new FieldAccessExpr(range(ret, token()), ret, emptyNodeList(), name);
4139	}
4140	break;
4141	}
4142	case DOUBLECOLON:{
4143	jj_consume_token(DOUBLECOLON);
4144	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4145	case LT:{
4146	typeArgs = TypeArguments();
4147	break;
4148	}
4149	default:
4150	jj_la1[96] = jj_gen;
4151	;
4152	}
4153	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4154	case ENUM:
4155	case STRICTFP:
4156	case YIELD:
4157	case REQUIRES:
4158	case TO:
4159	case WITH:
4160	case OPEN:
4161	case OPENS:
4162	case USES:
4163	case MODULE:
4164	case EXPORTS:
4165	case PROVIDES:
4166	case TRANSITIVE:
4167	case IDENTIFIER:{
4168	Identifier();
4169	break;
4170	}
4171	case NEW:{
4172	jj_consume_token(NEW);
4173	break;
4174	}
4175	default:
4176	jj_la1[97] = jj_gen;
4177	jj_consume_token(-1);
4178	throw new ParseException();
4179	}
4180	ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image);
4181	break;
4182	}
4183	default:
4184	jj_la1[98] = jj_gen;
4185	jj_consume_token(-1);
4186	throw new ParseException();
4187	}
4188	break;
4189	}
4190	case LPAREN:{
4191	jj_consume_token(LPAREN);
4192	begin=token();
4193	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4194	case RPAREN:{
4195	jj_consume_token(RPAREN);
4196	ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true);
4197	break;
4198	}
4199	default:
4200	jj_la1[99] = jj_gen;
4201	if (jj_2_33(2147483647)) {
4202	params = LambdaParameters();
4203	jj_consume_token(RPAREN);
4204	ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true);
4205	} else if (jj_2_34(2147483647)) {
4206	params = InferredLambdaParameters();
4207	jj_consume_token(RPAREN);
4208	ret = new LambdaExpr(range(begin, token()), params, new BlockStmt(), true);
4209	} else {
4210	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4211	case BOOLEAN:
4212	case BYTE:
4213	case CHAR:
4214	case DOUBLE:
4215	case ENUM:
4216	case FALSE:
4217	case FLOAT:
4218	case INT:
4219	case LONG:
4220	case NEW:
4221	case NULL:
4222	case SHORT:
4223	case STRICTFP:
4224	case SUPER:
4225	case SWITCH:
4226	case THIS:
4227	case TRUE:
4228	case VOID:
4229	case YIELD:
4230	case REQUIRES:
4231	case TO:
4232	case WITH:
4233	case OPEN:
4234	case OPENS:
4235	case USES:
4236	case MODULE:
4237	case EXPORTS:
4238	case PROVIDES:
4239	case TRANSITIVE:
4240	case LONG_LITERAL:
4241	case INTEGER_LITERAL:
4242	case FLOATING_POINT_LITERAL:
4243	case CHARACTER_LITERAL:
4244	case STRING_LITERAL:
4245	case TEXT_BLOCK_LITERAL:
4246	case IDENTIFIER:
4247	case LPAREN:
4248	case AT:
4249	case BANG:
4250	case TILDE:
4251	case INCR:
4252	case DECR:
4253	case PLUS:
4254	case MINUS:{
4255	// This could still be a lambda expression, but this is handled after matching -> elsewhere
4256	ret = Expression();
4257	jj_consume_token(RPAREN);
4258	ret = new EnclosedExpr(range(begin, token()), ret);
4259	break;
4260	}
4261	default:
4262	jj_la1[100] = jj_gen;
4263	jj_consume_token(-1);
4264	throw new ParseException();
4265	}
4266	}
4267	}
4268	break;
4269	}
4270	case NEW:{
4271	ret = AllocationExpression(null);
4272	break;
4273	}
4274	default:
4275	jj_la1[104] = jj_gen;
4276	if (jj_2_35(2147483647)) {
4277	type = ResultType(emptyNodeList());
4278	jj_consume_token(DOT);
4279	jj_consume_token(CLASS);
4280	ret = new ClassExpr(range(type, token()), type);
4281	} else if (jj_2_36(2147483647)) {
4282	type = AnnotatedType();
4283	jj_consume_token(DOUBLECOLON);
4284	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4285	case LT:{
4286	typeArgs = TypeArguments();
4287	break;
4288	}
4289	default:
4290	jj_la1[101] = jj_gen;
4291	;
4292	}
4293	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4294	case ENUM:
4295	case STRICTFP:
4296	case YIELD:
4297	case REQUIRES:
4298	case TO:
4299	case WITH:
4300	case OPEN:
4301	case OPENS:
4302	case USES:
4303	case MODULE:
4304	case EXPORTS:
4305	case PROVIDES:
4306	case TRANSITIVE:
4307	case IDENTIFIER:{
4308	Identifier();
4309	break;
4310	}
4311	case NEW:{
4312	jj_consume_token(NEW);
4313	break;
4314	}
4315	default:
4316	jj_la1[102] = jj_gen;
4317	jj_consume_token(-1);
4318	throw new ParseException();
4319	}
4320	ret = new TypeExpr(range(type, type), type);
4321	ret = new MethodReferenceExpr(range(ret, token()), ret, typeArgs.list, token.image);
4322	} else {
4323	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4324	case ENUM:
4325	case STRICTFP:
4326	case YIELD:
4327	case REQUIRES:
4328	case TO:
4329	case WITH:
4330	case OPEN:
4331	case OPENS:
4332	case USES:
4333	case MODULE:
4334	case EXPORTS:
4335	case PROVIDES:
4336	case TRANSITIVE:
4337	case IDENTIFIER:{
4338	name = SimpleName();
4339	begin=token();
4340	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4341	case LPAREN:{
4342	args = Arguments();
4343	hasArgs=true;
4344	break;
4345	}
4346	default:
4347	jj_la1[103] = jj_gen;
4348	;
4349	}
4350	if (hasArgs) {
4351	ret = new MethodCallExpr(range(begin, token()), null, null, name, args);
4352	} else {
4353	ret = new NameExpr(name);
4354	}
4355	break;
4356	}
4357	default:
4358	jj_la1[105] = jj_gen;
4359	jj_consume_token(-1);
4360	throw new ParseException();
4361	}
4362	}
4363	}
4364	{if ("" != null) return ret;}
4365	throw new IllegalStateException ("Missing return statement in function");
4366	}
4367
4368	/**
4369	* // TODO: Unclear exactly which part of the JLS this relates to - a JavaParser-specific thing with no 1:1 mapping, perhaps?
4370	*/
4371	final public Expression PrimarySuffix(Expression scope) throws ParseException {Expression ret;
4372	if (jj_2_37(2)) {
4373	ret = PrimarySuffixWithoutSuper(scope);
4374	} else {
4375	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4376	case DOT:{
4377	jj_consume_token(DOT);
4378	jj_consume_token(SUPER);
4379	ret = new SuperExpr(range(scope, token()), scopeToName(scope));
4380	break;
4381	}
4382	default:
4383	jj_la1[106] = jj_gen;
4384	jj_consume_token(-1);
4385	throw new ParseException();
4386	}
4387	}
4388	{if ("" != null) return ret;}
4389	throw new IllegalStateException ("Missing return statement in function");
4390	}
4391
4392	/**
4393	* // TODO: Unclear exactly which part of the JLS this relates to - a JavaParser-specific thing with no 1:1 mapping, perhaps?
4394	*/
4395	final public Expression PrimarySuffixWithoutSuper(Expression scope) throws ParseException {Expression ret;
4396	RangedList<Type> typeArgs = new RangedList<Type>(null);
4397	NodeList<Expression> args = emptyNodeList();
4398	boolean hasArgs = false;
4399	SimpleName name;
4400	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4401	case DOT:{
4402	jj_consume_token(DOT);
4403	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4404	case THIS:{
4405	jj_consume_token(THIS);
4406	ret = new ThisExpr(range(scope, token()), scopeToName(scope));
4407	break;
4408	}
4409	case NEW:{
4410	ret = AllocationExpression(scope);
4411	break;
4412	}
4413	default:
4414	jj_la1[109] = jj_gen;
4415	if (jj_2_38(2147483647)) {
4416	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4417	case LT:{
4418	typeArgs = TypeArguments();
4419	break;
4420	}
4421	default:
4422	jj_la1[107] = jj_gen;
4423	;
4424	}
4425	name = SimpleName();
4426	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4427	case LPAREN:{
4428	args = Arguments();
4429	hasArgs=true;
4430	break;
4431	}
4432	default:
4433	jj_la1[108] = jj_gen;
4434	;
4435	}
4436	if (hasArgs) {
4437	ret = new MethodCallExpr(range(scope, token()), scope, typeArgs.list, name, args);
4438	} else {
4439	ret = new FieldAccessExpr(range(scope, token()), scope, typeArgs.list, name);
4440	}
4441	} else {
4442	jj_consume_token(-1);
4443	throw new ParseException();
4444	}
4445	}
4446	break;
4447	}
4448	case LBRACKET:{
4449	jj_consume_token(LBRACKET);
4450	ret = Expression();
4451	jj_consume_token(RBRACKET);
4452	ret = new ArrayAccessExpr(range(scope, token()), scope, ret);
4453	break;
4454	}
4455	default:
4456	jj_la1[110] = jj_gen;
4457	jj_consume_token(-1);
4458	throw new ParseException();
4459	}
4460	{if ("" != null) return ret;}
4461	throw new IllegalStateException ("Missing return statement in function");
4462	}
4463
4464	/**
4465	* Note that a Long Literal is defined as an {@code IntegerLiteral}, suffixed by "L"
4466	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-3.html#jls-3.10.1
4467	* <pre>{@code
4468	* Literal:
4469	* IntegerLiteral
4470	* FloatingPointLiteral
4471	* BooleanLiteral
4472	* CharacterLiteral
4473	* StringLiteral
4474	* TextBlock
4475	* NullLiteral
4476	* }</pre>
4477	*/
4478	final public Expression Literal() throws ParseException {Expression ret;
4479	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4480	case INTEGER_LITERAL:{
4481	jj_consume_token(INTEGER_LITERAL);
4482	ret = new IntegerLiteralExpr(tokenRange(), token.image);
4483	break;
4484	}
4485	case LONG_LITERAL:{
4486	jj_consume_token(LONG_LITERAL);
4487	ret = new LongLiteralExpr(tokenRange(), token.image);
4488	break;
4489	}
4490	case FLOATING_POINT_LITERAL:{
4491	jj_consume_token(FLOATING_POINT_LITERAL);
4492	ret = new DoubleLiteralExpr(tokenRange(), token.image);
4493	break;
4494	}
4495	case CHARACTER_LITERAL:{
4496	jj_consume_token(CHARACTER_LITERAL);
4497	ret = new CharLiteralExpr(tokenRange(), unquote(token.image));
4498	break;
4499	}
4500	case STRING_LITERAL:{
4501	jj_consume_token(STRING_LITERAL);
4502	ret = new StringLiteralExpr(tokenRange(), unquote(token.image));
4503	break;
4504	}
4505	case TEXT_BLOCK_LITERAL:{
4506	jj_consume_token(TEXT_BLOCK_LITERAL);
4507	ret = new TextBlockLiteralExpr(tokenRange(), unTripleQuote(token.image));
4508	break;
4509	}
4510	case FALSE:
4511	case TRUE:{
4512	ret = BooleanLiteral();
4513	break;
4514	}
4515	case NULL:{
4516	ret = NullLiteral();
4517	break;
4518	}
4519	default:
4520	jj_la1[111] = jj_gen;
4521	jj_consume_token(-1);
4522	throw new ParseException();
4523	}
4524	{if ("" != null) return ret;}
4525	throw new IllegalStateException ("Missing return statement in function");
4526	}
4527
4528	/**
4529	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-3.html#jls-3.10.3
4530	* <pre>{@code
4531	* BooleanLiteral:
4532	* (one of)
4533	* true false
4534	* }</pre>
4535	*/
4536	final public Expression BooleanLiteral() throws ParseException {Expression ret;
4537	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4538	case TRUE:{
4539	jj_consume_token(TRUE);
4540	ret = new BooleanLiteralExpr(tokenRange(), true);
4541	break;
4542	}
4543	case FALSE:{
4544	jj_consume_token(FALSE);
4545	ret = new BooleanLiteralExpr(tokenRange(), false);
4546	break;
4547	}
4548	default:
4549	jj_la1[112] = jj_gen;
4550	jj_consume_token(-1);
4551	throw new ParseException();
4552	}
4553	{if ("" != null) return ret;}
4554	throw new IllegalStateException ("Missing return statement in function");
4555	}
4556
4557	/**
4558	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-3.html#jls-3.10.8
4559	* <pre>{@code
4560	* NullLiteral:
4561	* null
4562	* }</pre>
4563	*/
4564	final public Expression NullLiteral() throws ParseException {
4565	jj_consume_token(NULL);
4566	{if ("" != null) return new NullLiteralExpr(tokenRange());}
4567	throw new IllegalStateException ("Missing return statement in function");
4568	}
4569
4570	/**
4571	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.12
4572	* <pre>{@code
4573	* MethodInvocation:
4574	* MethodName ( [ArgumentList] )
4575	* TypeName . [TypeArguments] Identifier ( [ArgumentList] )
4576	* ExpressionName . [TypeArguments] Identifier ( [ArgumentList] )
4577	* Primary . [TypeArguments] Identifier ( [ArgumentList] )
4578	* super . [TypeArguments] Identifier ( [ArgumentList] )
4579	* TypeName . super . [TypeArguments] Identifier ( [ArgumentList] )
4580	* ArgumentList:
4581	* Expression {, Expression}
4582	* }</pre>
4583	*/
4584	final public NodeList<Expression> Arguments() throws ParseException {NodeList<Expression> ret = emptyNodeList();
4585	jj_consume_token(LPAREN);
4586	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4587	case BOOLEAN:
4588	case BYTE:
4589	case CHAR:
4590	case DOUBLE:
4591	case ENUM:
4592	case FALSE:
4593	case FLOAT:
4594	case INT:
4595	case LONG:
4596	case NEW:
4597	case NULL:
4598	case SHORT:
4599	case STRICTFP:
4600	case SUPER:
4601	case SWITCH:
4602	case THIS:
4603	case TRUE:
4604	case VOID:
4605	case YIELD:
4606	case REQUIRES:
4607	case TO:
4608	case WITH:
4609	case OPEN:
4610	case OPENS:
4611	case USES:
4612	case MODULE:
4613	case EXPORTS:
4614	case PROVIDES:
4615	case TRANSITIVE:
4616	case LONG_LITERAL:
4617	case INTEGER_LITERAL:
4618	case FLOATING_POINT_LITERAL:
4619	case CHARACTER_LITERAL:
4620	case STRING_LITERAL:
4621	case TEXT_BLOCK_LITERAL:
4622	case IDENTIFIER:
4623	case LPAREN:
4624	case AT:
4625	case BANG:
4626	case TILDE:
4627	case INCR:
4628	case DECR:
4629	case PLUS:
4630	case MINUS:{
4631	ret = ArgumentList();
4632	break;
4633	}
4634	default:
4635	jj_la1[113] = jj_gen;
4636	;
4637	}
4638	jj_consume_token(RPAREN);
4639	{if ("" != null) return ret;}
4640	throw new IllegalStateException ("Missing return statement in function");
4641	}
4642
4643	/**
4644	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.12
4645	* <pre>{@code
4646	* ArgumentList:
4647	* Expression {, Expression}
4648	* }</pre>
4649	*/
4650	final public NodeList<Expression> ArgumentList() throws ParseException {NodeList<Expression> ret = emptyNodeList();
4651	Expression expr;
4652	expr = Expression();
4653	ret.add(expr);
4654	label_41:
4655	while (true) {
4656	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4657	case COMMA:{
4658	break;
4659	}
4660	default:
4661	jj_la1[114] = jj_gen;
4662	break label_41;
4663	}
4664	jj_consume_token(COMMA);
4665	expr = Expression();
4666	ret.add(expr);
4667	}
4668	{if ("" != null) return ret;}
4669	throw new IllegalStateException ("Missing return statement in function");
4670	}
4671
4672	/**
4673	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.9
4674	* <pre>{@code
4675	* ClassInstanceCreationExpression:
4676	* UnqualifiedClassInstanceCreationExpression
4677	* ExpressionName . UnqualifiedClassInstanceCreationExpression
4678	* Primary . UnqualifiedClassInstanceCreationExpression
4679	* UnqualifiedClassInstanceCreationExpression:
4680	* new [TypeArguments] ClassOrInterfaceTypeToInstantiate ( [ArgumentList] ) [ClassBody]
4681	* ClassOrInterfaceTypeToInstantiate:
4682	* {Annotation} Identifier {. {Annotation} Identifier} [TypeArgumentsOrDiamond]
4683	* TypeArgumentsOrDiamond:
4684	* TypeArguments
4685	* <>
4686	* }</pre>
4687	* For Convenience:
4688	* <pre>{@code
4689	* ArgumentList:
4690	* Expression {, Expression}
4691	* }</pre>
4692	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.10
4693	* <pre>{@code
4694	* ArrayCreationExpression:
4695	* new PrimitiveType DimExprs [Dims]
4696	* new ClassOrInterfaceType DimExprs [Dims]
4697	* new PrimitiveType Dims ArrayInitializer
4698	* new ClassOrInterfaceType Dims ArrayInitializer
4699	* DimExprs:
4700	* DimExpr {DimExpr}
4701	* DimExpr:
4702	* {Annotation} [ Expression ]
4703	* }</pre>
4704	* For Convenience:
4705	* <pre>{@code
4706	* Dims:
4707	* {Annotation} [ ] {{Annotation} [ ]}
4708	* }</pre>
4709	*/
4710	final public Expression AllocationExpression(Expression scope) throws ParseException {Expression ret;
4711	Type type;
4712	RangedList<Type> typeArgs = new RangedList<Type>(null);
4713	NodeList<BodyDeclaration<?>> anonymousBody = null;
4714	NodeList<Expression> args;
4715	JavaToken begin = INVALID;
4716	NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
4717	jj_consume_token(NEW);
4718	if(scope==null) { begin=token(); } else { begin = orIfInvalid(begin, scope); }
4719	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4720	case LT:{
4721	typeArgs = TypeArguments();
4722	break;
4723	}
4724	default:
4725	jj_la1[115] = jj_gen;
4726	;
4727	}
4728	annotations = Annotations();
4729	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4730	case BOOLEAN:
4731	case BYTE:
4732	case CHAR:
4733	case DOUBLE:
4734	case FLOAT:
4735	case INT:
4736	case LONG:
4737	case SHORT:{
4738	// new array of primitives
4739	type = PrimitiveType(annotations);
4740	ret = ArrayCreation(begin, type);
4741	break;
4742	}
4743	case ENUM:
4744	case STRICTFP:
4745	case YIELD:
4746	case REQUIRES:
4747	case TO:
4748	case WITH:
4749	case OPEN:
4750	case OPENS:
4751	case USES:
4752	case MODULE:
4753	case EXPORTS:
4754	case PROVIDES:
4755	case TRANSITIVE:
4756	case IDENTIFIER:{
4757	// new reference type e.g. class (or an array of those)
4758	type = ClassOrInterfaceType(annotations);
4759	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4760	case LBRACKET:
4761	case AT:{
4762	// new Integer[6] -- the array doesn't have parameters.
4763	ret = ArrayCreation(begin, type);
4764	break;
4765	}
4766	case LPAREN:{
4767	// new Integer(6) -- not an array if parameters being passed.
4768	args = Arguments();
4769	if (jj_2_39(2)) {
4770	anonymousBody = ClassOrInterfaceBody();
4771	} else {
4772	;
4773	}
4774	ret = new ObjectCreationExpr(range(begin, token()), scope, (ClassOrInterfaceType) type, typeArgs.list, args, anonymousBody);
4775	break;
4776	}
4777	default:
4778	jj_la1[116] = jj_gen;
4779	jj_consume_token(-1);
4780	throw new ParseException();
4781	}
4782	break;
4783	}
4784	default:
4785	jj_la1[117] = jj_gen;
4786	jj_consume_token(-1);
4787	throw new ParseException();
4788	}
4789	{if ("" != null) return ret;}
4790	throw new IllegalStateException ("Missing return statement in function");
4791	}
4792
4793	/**
4794	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.10
4795	* <pre>{@code
4796	* ArrayCreationExpression:
4797	* new PrimitiveType DimExprs [Dims]
4798	* new ClassOrInterfaceType DimExprs [Dims]
4799	* new PrimitiveType Dims ArrayInitializer
4800	* new ClassOrInterfaceType Dims ArrayInitializer
4801	* DimExprs:
4802	* DimExpr {DimExpr}
4803	* DimExpr:
4804	* {Annotation} [ Expression ]
4805	* }</pre>
4806	* For Convenience:
4807	* <pre>{@code
4808	* Dims:
4809	* {Annotation} [ ] {{Annotation} [ ]}
4810	* }</pre>
4811	*/
4812	final public ArrayCreationExpr ArrayCreation(JavaToken begin, Type type) throws ParseException {Expression expr = null;
4813	ArrayInitializerExpr arrayInitializerExpr = null;
4814	NodeList<Expression> inits = emptyNodeList();
4815	List<NodeList<AnnotationExpr>> accum = new ArrayList<NodeList<AnnotationExpr>>();
4816	NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
4817	JavaToken arrayCreationLevelStart = INVALID;
4818	List<TokenRange> levelRanges = new ArrayList<TokenRange>();
4819	label_42:
4820	while (true) {
4821	annotations = Annotations();
4822	jj_consume_token(LBRACKET);
4823	arrayCreationLevelStart = annotations.isEmpty() ? token() : orIfInvalid(arrayCreationLevelStart, annotations.get(0));
4824	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4825	case BOOLEAN:
4826	case BYTE:
4827	case CHAR:
4828	case DOUBLE:
4829	case ENUM:
4830	case FALSE:
4831	case FLOAT:
4832	case INT:
4833	case LONG:
4834	case NEW:
4835	case NULL:
4836	case SHORT:
4837	case STRICTFP:
4838	case SUPER:
4839	case SWITCH:
4840	case THIS:
4841	case TRUE:
4842	case VOID:
4843	case YIELD:
4844	case REQUIRES:
4845	case TO:
4846	case WITH:
4847	case OPEN:
4848	case OPENS:
4849	case USES:
4850	case MODULE:
4851	case EXPORTS:
4852	case PROVIDES:
4853	case TRANSITIVE:
4854	case LONG_LITERAL:
4855	case INTEGER_LITERAL:
4856	case FLOATING_POINT_LITERAL:
4857	case CHARACTER_LITERAL:
4858	case STRING_LITERAL:
4859	case TEXT_BLOCK_LITERAL:
4860	case IDENTIFIER:
4861	case LPAREN:
4862	case AT:
4863	case BANG:
4864	case TILDE:
4865	case INCR:
4866	case DECR:
4867	case PLUS:
4868	case MINUS:{
4869	expr = Expression();
4870	break;
4871	}
4872	default:
4873	jj_la1[118] = jj_gen;
4874	;
4875	}
4876	accum = add(accum, annotations); inits = add(inits, expr); annotations=null; expr=null;
4877	jj_consume_token(RBRACKET);
4878	levelRanges.add(range(arrayCreationLevelStart, token()));
4879	if (jj_2_40(2)) {
4880	} else {
4881	break label_42;
4882	}
4883	}
4884	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4885	case LBRACE:{
4886	arrayInitializerExpr = ArrayInitializer();
4887	break;
4888	}
4889	default:
4890	jj_la1[119] = jj_gen;
4891	;
4892	}
4893	{if ("" != null) return juggleArrayCreation(range(begin, token()), levelRanges, type, inits, accum, arrayInitializerExpr);}
4894	throw new IllegalStateException ("Missing return statement in function");
4895	}
4896
4897	/*
4898	* Statement syntax follows.
4899	*/
4900
4901	/**
4902	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.5
4903	* <pre>{@code
4904	* Statement:
4905	* StatementWithoutTrailingSubstatement
4906	* LabeledStatement
4907	* IfThenStatement
4908	* IfThenElseStatement
4909	* WhileStatement
4910	* ForStatement
4911	* StatementNoShortIf:
4912	* StatementWithoutTrailingSubstatement
4913	* LabeledStatementNoShortIf
4914	* IfThenElseStatementNoShortIf
4915	* WhileStatementNoShortIf
4916	* ForStatementNoShortIf
4917	* StatementWithoutTrailingSubstatement:
4918	* Block
4919	* EmptyStatement
4920	* ExpressionStatement
4921	* AssertStatement
4922	* SwitchStatement
4923	* DoStatement
4924	* BreakStatement
4925	* ContinueStatement
4926	* ReturnStatement
4927	* SynchronizedStatement
4928	* ThrowStatement
4929	* TryStatement
4930	* YieldStatement
4931	* }</pre>
4932	*/
4933	final public Statement Statement() throws ParseException {Statement ret;
4934	try {
4935	if (jj_2_41(2)) {
4936	ret = LabeledStatement();
4937	} else {
4938	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4939	case ASSERT:{
4940	ret = AssertStatement();
4941	break;
4942	}
4943	default:
4944	jj_la1[120] = jj_gen;
4945	if (jj_2_42(3)) {
4946	ret = YieldStatement();
4947	} else {
4948	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
4949	case LBRACE:{
4950	ret = Block();
4951	break;
4952	}
4953	case SEMICOLON:{
4954	ret = EmptyStatement();
4955	break;
4956	}
4957	case BOOLEAN:
4958	case BYTE:
4959	case CHAR:
4960	case DOUBLE:
4961	case ENUM:
4962	case FALSE:
4963	case FLOAT:
4964	case INT:
4965	case LONG:
4966	case NEW:
4967	case NULL:
4968	case SHORT:
4969	case STRICTFP:
4970	case SUPER:
4971	case THIS:
4972	case TRUE:
4973	case VOID:
4974	case YIELD:
4975	case REQUIRES:
4976	case TO:
4977	case WITH:
4978	case OPEN:
4979	case OPENS:
4980	case USES:
4981	case MODULE:
4982	case EXPORTS:
4983	case PROVIDES:
4984	case TRANSITIVE:
4985	case LONG_LITERAL:
4986	case INTEGER_LITERAL:
4987	case FLOATING_POINT_LITERAL:
4988	case CHARACTER_LITERAL:
4989	case STRING_LITERAL:
4990	case TEXT_BLOCK_LITERAL:
4991	case IDENTIFIER:
4992	case LPAREN:
4993	case AT:
4994	case INCR:
4995	case DECR:{
4996	ret = StatementExpression();
4997	break;
4998	}
4999	case SWITCH:{
5000	ret = SwitchStatement();
5001	break;
5002	}
5003	case IF:{
5004	ret = IfStatement();
5005	break;
5006	}
5007	case WHILE:{
5008	ret = WhileStatement();
5009	break;
5010	}
5011	case DO:{
5012	ret = DoStatement();
5013	break;
5014	}
5015	case FOR:{
5016	ret = ForStatement();
5017	break;
5018	}
5019	case BREAK:{
5020	ret = BreakStatement();
5021	break;
5022	}
5023	case CONTINUE:{
5024	ret = ContinueStatement();
5025	break;
5026	}
5027	case RETURN:{
5028	ret = ReturnStatement();
5029	break;
5030	}
5031	case THROW:{
5032	ret = ThrowStatement();
5033	break;
5034	}
5035	case SYNCHRONIZED:{
5036	ret = SynchronizedStatement();
5037	break;
5038	}
5039	case TRY:{
5040	ret = TryStatement();
5041	break;
5042	}
5043	default:
5044	jj_la1[121] = jj_gen;
5045	jj_consume_token(-1);
5046	throw new ParseException();
5047	}
5048	}
5049	}
5050	}
5051	{if ("" != null) return ret;}
5052	} catch (ParseException e) {
5053	TokenRange errorRange = recover(SEMICOLON, e);
5054	{if ("" != null) return new UnparsableStmt(errorRange);}
5055	}
5056	throw new IllegalStateException ("Missing return statement in function");
5057	}
5058
5059	/**
5060	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.10
5061	* <pre>{@code
5062	* AssertStatement:
5063	* assert Expression ;
5064	* assert Expression : Expression ;
5065	* }</pre>
5066	*/
5067	final public AssertStmt AssertStatement() throws ParseException {Expression check;
5068	Expression msg = null;
5069	JavaToken begin;
5070	jj_consume_token(ASSERT);
5071	begin=token();
5072	check = Expression();
5073	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5074	case COLON:{
5075	jj_consume_token(COLON);
5076	msg = Expression();
5077	break;
5078	}
5079	default:
5080	jj_la1[122] = jj_gen;
5081	;
5082	}
5083	jj_consume_token(SEMICOLON);
5084	{if ("" != null) return new AssertStmt(range(begin, token()), check, msg);}
5085	throw new IllegalStateException ("Missing return statement in function");
5086	}
5087
5088	/**
5089	* // TODO: Examine more closely.
5090	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.7
5091	* <pre>{@code
5092	* LabeledStatement:
5093	* Identifier : Statement
5094	* LabeledStatementNoShortIf:
5095	* Identifier : StatementNoShortIf
5096	* }</pre>
5097	*/
5098	final public LabeledStmt LabeledStatement() throws ParseException {SimpleName label;
5099	Statement stmt;
5100	JavaToken begin;
5101	label = SimpleName();
5102	begin=token();
5103	jj_consume_token(COLON);
5104	stmt = Statement();
5105	{if ("" != null) return new LabeledStmt(range(begin, token()), label, stmt);}
5106	throw new IllegalStateException ("Missing return statement in function");
5107	}
5108
5109	/**
5110	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.2
5111	* <pre>{@code
5112	* Block:
5113	* { [BlockStatements] }
5114	* BlockStatements:
5115	* BlockStatement {BlockStatement}
5116	* BlockStatement:
5117	* LocalVariableDeclarationStatement
5118	* ClassDeclaration
5119	* Statement
5120	* }</pre>
5121	*/
5122	final public BlockStmt Block() throws ParseException {NodeList<Statement> stmts = emptyNodeList();
5123	JavaToken begin;
5124	jj_consume_token(LBRACE);
5125	begin=token();
5126	try {
5127	stmts = Statements();
5128	jj_consume_token(RBRACE);
5129	{if ("" != null) return new BlockStmt(range(begin, token()), stmts);}
5130	} catch (ParseException e) {
5131	recover(RBRACE, e);
5132	BlockStmt block = new BlockStmt(range(begin, token()), new NodeList<Statement>());
5133	block.setParsed(UNPARSABLE);
5134	{if ("" != null) return block;}
5135	}
5136	throw new IllegalStateException ("Missing return statement in function");
5137	}
5138
5139	/**
5140	* Classes inside body statements can only be abstract or final. The semantic checks must check it.
5141	* TODO/FIXME: Note that the JLS specifies {@code ClassDeclaration} (thus {@code NormalClassDeclaration} and {@code EnumDeclaration}, but not interface.
5142	* TODO/FIXME: Is this a bug in the grammar?
5143	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-Statement
5144	* <pre>{@code
5145	* Block:
5146	* { [BlockStatements] }
5147	* BlockStatements:
5148	* BlockStatement {BlockStatement}
5149	* BlockStatement:
5150	* LocalVariableDeclarationStatement
5151	* ClassDeclaration
5152	* Statement
5153	* }</pre>
5154	* For Convenience:
5155	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.1
5156	* <pre>{@code
5157	* ClassDeclaration:
5158	* NormalClassDeclaration
5159	* EnumDeclaration
5160	* NormalClassDeclaration:
5161	* {ClassModifier} class TypeIdentifier [TypeParameters] [Superclass] [Superinterfaces] ClassBody
5162	* }</pre>
5163	* For Convenience:
5164	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-8.html#jls-8.9
5165	* <pre>{@code
5166	* EnumDeclaration:
5167	* {ClassModifier} enum TypeIdentifier [Superinterfaces] EnumBody
5168	* }</pre>
5169	*
5170	*/
5171	final public Statement BlockStatement() throws ParseException {Statement ret;
5172	Expression expr;
5173	ClassOrInterfaceDeclaration typeDecl;
5174	ModifierHolder modifier;
5175	try {
5176	if (jj_2_43(2147483647)) {
5177	// TODO/FIXME: Is this a bug in the grammar? JLS specifies class or enum, not interface.
5178	modifier = Modifiers();
5179	typeDecl = ClassOrInterfaceDeclaration(modifier);
5180	ret = new LocalClassDeclarationStmt(range(typeDecl, token()), typeDecl);
5181	} else if (jj_2_44(2147483647)) {
5182	expr = VariableDeclarationExpression();
5183	jj_consume_token(SEMICOLON);
5184	ret = new ExpressionStmt(range(expr, token()), expr);
5185	} else {
5186	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5187	case ASSERT:
5188	case BOOLEAN:
5189	case BREAK:
5190	case BYTE:
5191	case CHAR:
5192	case CONTINUE:
5193	case DO:
5194	case DOUBLE:
5195	case ENUM:
5196	case FALSE:
5197	case FLOAT:
5198	case FOR:
5199	case IF:
5200	case INT:
5201	case LONG:
5202	case NEW:
5203	case NULL:
5204	case RETURN:
5205	case SHORT:
5206	case STRICTFP:
5207	case SUPER:
5208	case SWITCH:
5209	case SYNCHRONIZED:
5210	case THIS:
5211	case THROW:
5212	case TRUE:
5213	case TRY:
5214	case VOID:
5215	case WHILE:
5216	case YIELD:
5217	case REQUIRES:
5218	case TO:
5219	case WITH:
5220	case OPEN:
5221	case OPENS:
5222	case USES:
5223	case MODULE:
5224	case EXPORTS:
5225	case PROVIDES:
5226	case TRANSITIVE:
5227	case LONG_LITERAL:
5228	case INTEGER_LITERAL:
5229	case FLOATING_POINT_LITERAL:
5230	case CHARACTER_LITERAL:
5231	case STRING_LITERAL:
5232	case TEXT_BLOCK_LITERAL:
5233	case IDENTIFIER:
5234	case LPAREN:
5235	case LBRACE:
5236	case SEMICOLON:
5237	case AT:
5238	case INCR:
5239	case DECR:{
5240	ret = Statement();
5241	break;
5242	}
5243	default:
5244	jj_la1[123] = jj_gen;
5245	jj_consume_token(-1);
5246	throw new ParseException();
5247	}
5248	}
5249	{if ("" != null) return ret;}
5250	} catch (ParseException e) {
5251	TokenRange errorRange = recover(SEMICOLON, e);
5252	{if ("" != null) return new UnparsableStmt(errorRange);}
5253	}
5254	throw new IllegalStateException ("Missing return statement in function");
5255	}
5256
5257	final public VariableDeclarationExpr VariableDeclarationExpression() throws ParseException {ModifierHolder modifier;
5258	Type partialType;
5259	NodeList<VariableDeclarator> variables = new NodeList<VariableDeclarator>();
5260	VariableDeclarator var;
5261	modifier = Modifiers();
5262	partialType = Type(emptyNodeList());
5263	var = VariableDeclarator(partialType);
5264	variables.add(var);
5265	label_43:
5266	while (true) {
5267	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5268	case COMMA:{
5269	break;
5270	}
5271	default:
5272	jj_la1[124] = jj_gen;
5273	break label_43;
5274	}
5275	jj_consume_token(COMMA);
5276	var = VariableDeclarator(partialType);
5277	variables.add(var);
5278	}
5279	JavaToken begin=orIfInvalid(modifier.begin, partialType);
5280	{if ("" != null) return new VariableDeclarationExpr(range(begin, token()), modifier.modifiers, modifier.annotations, variables);}
5281	throw new IllegalStateException ("Missing return statement in function");
5282	}
5283
5284	/**
5285	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.6
5286	* <pre>{@code
5287	* EmptyStatement:
5288	* ;
5289	* }</pre>
5290	*/
5291	final public EmptyStmt EmptyStatement() throws ParseException {
5292	jj_consume_token(SEMICOLON);
5293	{if ("" != null) return new EmptyStmt(tokenRange());}
5294	throw new IllegalStateException ("Missing return statement in function");
5295	}
5296
5297	/**
5298	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.27.2
5299	* <pre>{@code
5300	* LambdaBody:
5301	* Expression
5302	* Block
5303	* }</pre>
5304	*/
5305	final public Statement LambdaBody() throws ParseException {Expression expr;
5306	Statement n = null;
5307	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5308	case BOOLEAN:
5309	case BYTE:
5310	case CHAR:
5311	case DOUBLE:
5312	case ENUM:
5313	case FALSE:
5314	case FLOAT:
5315	case INT:
5316	case LONG:
5317	case NEW:
5318	case NULL:
5319	case SHORT:
5320	case STRICTFP:
5321	case SUPER:
5322	case SWITCH:
5323	case THIS:
5324	case TRUE:
5325	case VOID:
5326	case YIELD:
5327	case REQUIRES:
5328	case TO:
5329	case WITH:
5330	case OPEN:
5331	case OPENS:
5332	case USES:
5333	case MODULE:
5334	case EXPORTS:
5335	case PROVIDES:
5336	case TRANSITIVE:
5337	case LONG_LITERAL:
5338	case INTEGER_LITERAL:
5339	case FLOATING_POINT_LITERAL:
5340	case CHARACTER_LITERAL:
5341	case STRING_LITERAL:
5342	case TEXT_BLOCK_LITERAL:
5343	case IDENTIFIER:
5344	case LPAREN:
5345	case AT:
5346	case BANG:
5347	case TILDE:
5348	case INCR:
5349	case DECR:
5350	case PLUS:
5351	case MINUS:{
5352	expr = Expression();
5353	n = new ExpressionStmt(range(expr, token()), expr);
5354	break;
5355	}
5356	case LBRACE:{
5357	n = Block();
5358	break;
5359	}
5360	default:
5361	jj_la1[125] = jj_gen;
5362	jj_consume_token(-1);
5363	throw new ParseException();
5364	}
5365	{if ("" != null) return n;}
5366	throw new IllegalStateException ("Missing return statement in function");
5367	}
5368
5369	final public ExpressionStmt StatementExpression() throws ParseException {Expression expr;
5370	AssignExpr.Operator op;
5371	Expression value;
5372	RangedList<Type> typeArgs = new RangedList<Type>(null);
5373	Statement lambdaBody;
5374	if (jj_2_45(2)) {
5375	expr = PreIncrementExpression();
5376	} else {
5377	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5378	case DECR:{
5379	expr = PreDecrementExpression();
5380	break;
5381	}
5382	case BOOLEAN:
5383	case BYTE:
5384	case CHAR:
5385	case DOUBLE:
5386	case ENUM:
5387	case FALSE:
5388	case FLOAT:
5389	case INT:
5390	case LONG:
5391	case NEW:
5392	case NULL:
5393	case SHORT:
5394	case STRICTFP:
5395	case SUPER:
5396	case THIS:
5397	case TRUE:
5398	case VOID:
5399	case YIELD:
5400	case REQUIRES:
5401	case TO:
5402	case WITH:
5403	case OPEN:
5404	case OPENS:
5405	case USES:
5406	case MODULE:
5407	case EXPORTS:
5408	case PROVIDES:
5409	case TRANSITIVE:
5410	case LONG_LITERAL:
5411	case INTEGER_LITERAL:
5412	case FLOATING_POINT_LITERAL:
5413	case CHARACTER_LITERAL:
5414	case STRING_LITERAL:
5415	case TEXT_BLOCK_LITERAL:
5416	case IDENTIFIER:
5417	case LPAREN:
5418	case AT:{
5419	expr = PrimaryExpression();
5420	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5421	case ASSIGN:
5422	case INCR:
5423	case DECR:
5424	case PLUSASSIGN:
5425	case MINUSASSIGN:
5426	case STARASSIGN:
5427	case SLASHASSIGN:
5428	case ANDASSIGN:
5429	case ORASSIGN:
5430	case XORASSIGN:
5431	case REMASSIGN:
5432	case LSHIFTASSIGN:
5433	case RSIGNEDSHIFTASSIGN:
5434	case RUNSIGNEDSHIFTASSIGN:{
5435	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5436	case INCR:{
5437	jj_consume_token(INCR);
5438	expr = new UnaryExpr(range(expr, token()), expr, UnaryExpr.Operator.POSTFIX_INCREMENT);
5439	break;
5440	}
5441	case DECR:{
5442	jj_consume_token(DECR);
5443	expr = new UnaryExpr(range(expr, token()), expr, UnaryExpr.Operator.POSTFIX_DECREMENT);
5444	break;
5445	}
5446	case ASSIGN:
5447	case PLUSASSIGN:
5448	case MINUSASSIGN:
5449	case STARASSIGN:
5450	case SLASHASSIGN:
5451	case ANDASSIGN:
5452	case ORASSIGN:
5453	case XORASSIGN:
5454	case REMASSIGN:
5455	case LSHIFTASSIGN:
5456	case RSIGNEDSHIFTASSIGN:
5457	case RUNSIGNEDSHIFTASSIGN:{
5458	op = AssignmentOperator();
5459	value = Expression();
5460	expr = new AssignExpr(range(expr, token()), expr, value, op);
5461	break;
5462	}
5463	default:
5464	jj_la1[126] = jj_gen;
5465	jj_consume_token(-1);
5466	throw new ParseException();
5467	}
5468	break;
5469	}
5470	default:
5471	jj_la1[127] = jj_gen;
5472	;
5473	}
5474	break;
5475	}
5476	default:
5477	jj_la1[128] = jj_gen;
5478	jj_consume_token(-1);
5479	throw new ParseException();
5480	}
5481	}
5482	jj_consume_token(SEMICOLON);
5483	{if ("" != null) return new ExpressionStmt(range(expr, token()), expr);}
5484	throw new IllegalStateException ("Missing return statement in function");
5485	}
5486
5487	/**
5488	* Note that the {@code SwitchExpression} and {@code SwitchStatemnt} are similar but different. // TODO: Why/How?
5489	* // TODO: Examine more closely.
5490	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.11
5491	* <pre>{@code
5492	* SwitchStatement:
5493	* switch ( Expression ) SwitchBlock
5494	* }</pre>
5495	* For Convenience:
5496	* <pre>{@code
5497	* SwitchBlock:
5498	* { SwitchRule {SwitchRule} }
5499	* { {SwitchBlockStatementGroup} {SwitchLabel :} }
5500	* SwitchRule:
5501	* SwitchLabel -> Expression ;
5502	* SwitchLabel -> Block
5503	* SwitchLabel -> ThrowStatement
5504	* SwitchBlockStatementGroup:
5505	* SwitchLabel : {SwitchLabel :} BlockStatements
5506	* SwitchLabel:
5507	* case CaseConstant {, CaseConstant}
5508	* default
5509	* CaseConstant:
5510	* ConditionalExpression
5511	* }</pre>
5512	*/
5513	final public SwitchStmt SwitchStatement() throws ParseException {Expression selector;
5514	SwitchEntry entry;
5515	NodeList<SwitchEntry> entries = emptyNodeList() ;
5516	JavaToken begin;
5517	jj_consume_token(SWITCH);
5518	begin=token();
5519	jj_consume_token(LPAREN);
5520	selector = Expression();
5521	jj_consume_token(RPAREN);
5522	jj_consume_token(LBRACE);
5523	label_44:
5524	while (true) {
5525	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5526	case CASE:
5527	case _DEFAULT:{
5528	break;
5529	}
5530	default:
5531	jj_la1[129] = jj_gen;
5532	break label_44;
5533	}
5534	entry = SwitchEntry();
5535	entries = add(entries, entry);
5536	}
5537	jj_consume_token(RBRACE);
5538	{if ("" != null) return new SwitchStmt(range(begin, token()), selector, entries);}
5539	throw new IllegalStateException ("Missing return statement in function");
5540	}
5541
5542	/**
5543	* Note that the {@code SwitchExpression} and {@code SwitchStatemnt} are similar but different. // TODO: Why/How?
5544	* // TODO: Examine more closely.
5545	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-15.html#jls-15.28
5546	* <pre>{@code
5547	* SwitchExpression:
5548	* switch ( Expression ) SwitchBlock
5549	* }</pre>
5550	* For Convenience:
5551	* <pre>{@code
5552	* SwitchBlock:
5553	* { SwitchRule {SwitchRule} }
5554	* { {SwitchBlockStatementGroup} {SwitchLabel :} }
5555	* SwitchRule:
5556	* SwitchLabel -> Expression ;
5557	* SwitchLabel -> Block
5558	* SwitchLabel -> ThrowStatement
5559	* SwitchBlockStatementGroup:
5560	* SwitchLabel : {SwitchLabel :} BlockStatements
5561	* SwitchLabel:
5562	* case CaseConstant {, CaseConstant}
5563	* default
5564	* CaseConstant:
5565	* ConditionalExpression
5566	* }</pre>
5567	*/
5568	final public SwitchExpr SwitchExpression() throws ParseException {Expression selector;
5569	SwitchEntry entry;
5570	NodeList<SwitchEntry> entries = emptyNodeList();
5571	JavaToken begin;
5572	jj_consume_token(SWITCH);
5573	begin=token();
5574	jj_consume_token(LPAREN);
5575	selector = Expression();
5576	jj_consume_token(RPAREN);
5577	jj_consume_token(LBRACE);
5578	label_45:
5579	while (true) {
5580	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5581	case CASE:
5582	case _DEFAULT:{
5583	break;
5584	}
5585	default:
5586	jj_la1[130] = jj_gen;
5587	break label_45;
5588	}
5589	entry = SwitchEntry();
5590	entries = add(entries, entry);
5591	}
5592	jj_consume_token(RBRACE);
5593	{if ("" != null) return new SwitchExpr(range(begin, token()), selector, entries);}
5594	throw new IllegalStateException ("Missing return statement in function");
5595	}
5596
5597	/**
5598	* Note that the {@code SwitchBlock} (JLS) and {@code SwitchEntry} (JavaParser) are equivlent.
5599	* // TODO: Examine more closely.
5600	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.11.1
5601	* <pre>{@code
5602	* SwitchBlock:
5603	* { SwitchRule {SwitchRule} }
5604	* { {SwitchBlockStatementGroup} {SwitchLabel :} }
5605	* SwitchRule:
5606	* SwitchLabel -> Expression ;
5607	* SwitchLabel -> Block
5608	* SwitchLabel -> ThrowStatement
5609	* SwitchBlockStatementGroup:
5610	* SwitchLabel : {SwitchLabel :} BlockStatements
5611	* SwitchLabel:
5612	* case CaseConstant {, CaseConstant}
5613	* default
5614	* CaseConstant:
5615	* ConditionalExpression
5616	* }</pre>
5617	*/
5618	final public SwitchEntry SwitchEntry() throws ParseException {Expression label = null;
5619	NodeList<Expression> labels = emptyNodeList();
5620	NodeList<Statement> stmts = emptyNodeList();
5621	JavaToken begin;
5622	SwitchEntry ret;
5623	Expression expression = null;
5624	Statement stmt = null;
5625	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5626	case CASE:{
5627	jj_consume_token(CASE);
5628	begin=token();
5629	label = ConditionalExpression();
5630	labels = add(labels, label);
5631	label_46:
5632	while (true) {
5633	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5634	case COMMA:{
5635	break;
5636	}
5637	default:
5638	jj_la1[131] = jj_gen;
5639	break label_46;
5640	}
5641	jj_consume_token(COMMA);
5642	label = ConditionalExpression();
5643	labels = add(labels, label);
5644	}
5645	break;
5646	}
5647	case _DEFAULT:{
5648	jj_consume_token(_DEFAULT);
5649	begin=token();
5650	break;
5651	}
5652	default:
5653	jj_la1[132] = jj_gen;
5654	jj_consume_token(-1);
5655	throw new ParseException();
5656	}
5657	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5658	case COLON:{
5659	jj_consume_token(COLON);
5660	stmts = Statements();
5661	ret = new SwitchEntry(range(begin, token()), labels, STATEMENT_GROUP, stmts);
5662	break;
5663	}
5664	case ARROW:{
5665	jj_consume_token(ARROW);
5666	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5667	case BOOLEAN:
5668	case BYTE:
5669	case CHAR:
5670	case DOUBLE:
5671	case ENUM:
5672	case FALSE:
5673	case FLOAT:
5674	case INT:
5675	case LONG:
5676	case NEW:
5677	case NULL:
5678	case SHORT:
5679	case STRICTFP:
5680	case SUPER:
5681	case SWITCH:
5682	case THIS:
5683	case TRUE:
5684	case VOID:
5685	case YIELD:
5686	case REQUIRES:
5687	case TO:
5688	case WITH:
5689	case OPEN:
5690	case OPENS:
5691	case USES:
5692	case MODULE:
5693	case EXPORTS:
5694	case PROVIDES:
5695	case TRANSITIVE:
5696	case LONG_LITERAL:
5697	case INTEGER_LITERAL:
5698	case FLOATING_POINT_LITERAL:
5699	case CHARACTER_LITERAL:
5700	case STRING_LITERAL:
5701	case TEXT_BLOCK_LITERAL:
5702	case IDENTIFIER:
5703	case LPAREN:
5704	case AT:
5705	case BANG:
5706	case TILDE:
5707	case INCR:
5708	case DECR:
5709	case PLUS:
5710	case MINUS:{
5711	expression = Expression();
5712	jj_consume_token(SEMICOLON);
5713	TokenRange r=range(begin, token());
5714	stmts.add(new ExpressionStmt(r, expression));
5715	ret = new SwitchEntry(r, labels, EXPRESSION, stmts);
5716	break;
5717	}
5718	case LBRACE:{
5719	stmt = Block();
5720	TokenRange r=range(begin, token());
5721	stmts.add(stmt);
5722	ret = new SwitchEntry(r, labels, BLOCK, stmts);
5723	break;
5724	}
5725	case THROW:{
5726	stmt = ThrowStatement();
5727	TokenRange r=range(begin, token());
5728	stmts.add(stmt);
5729	ret = new SwitchEntry(r, labels, THROWS_STATEMENT, stmts);
5730	break;
5731	}
5732	default:
5733	jj_la1[133] = jj_gen;
5734	jj_consume_token(-1);
5735	throw new ParseException();
5736	}
5737	break;
5738	}
5739	default:
5740	jj_la1[134] = jj_gen;
5741	jj_consume_token(-1);
5742	throw new ParseException();
5743	}
5744	{if ("" != null) return ret;}
5745	throw new IllegalStateException ("Missing return statement in function");
5746	}
5747
5748	/**
5749	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.9
5750	* <pre>{@code
5751	* IfThenStatement:
5752	* if ( Expression ) Statement
5753	* IfThenElseStatement:
5754	* if ( Expression ) StatementNoShortIf else Statement
5755	* IfThenElseStatementNoShortIf:
5756	* if ( Expression ) StatementNoShortIf else StatementNoShortIf
5757	* }</pre>
5758	*/
5759	final public IfStmt IfStatement() throws ParseException {Expression condition;
5760	Statement thenStmt;
5761	Statement elseStmt = null;
5762	JavaToken begin;
5763	jj_consume_token(IF);
5764	begin=token();
5765	jj_consume_token(LPAREN);
5766	condition = Expression();
5767	jj_consume_token(RPAREN);
5768	thenStmt = Statement();
5769	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5770	case ELSE:{
5771	jj_consume_token(ELSE);
5772	elseStmt = Statement();
5773	break;
5774	}
5775	default:
5776	jj_la1[135] = jj_gen;
5777	;
5778	}
5779	{if ("" != null) return new IfStmt(range(begin, token()), condition, thenStmt, elseStmt);}
5780	throw new IllegalStateException ("Missing return statement in function");
5781	}
5782
5783	/**
5784	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.12
5785	* <pre>{@code
5786	* WhileStatement:
5787	* while ( Expression ) Statement
5788	* WhileStatementNoShortIf:
5789	* while ( Expression ) StatementNoShortIf
5790	* }</pre>
5791	*/
5792	final public WhileStmt WhileStatement() throws ParseException {Expression condition;
5793	Statement body;
5794	JavaToken begin;
5795	jj_consume_token(WHILE);
5796	begin=token();
5797	jj_consume_token(LPAREN);
5798	condition = Expression();
5799	jj_consume_token(RPAREN);
5800	body = Statement();
5801	{if ("" != null) return new WhileStmt(range(begin, token()),condition, body);}
5802	throw new IllegalStateException ("Missing return statement in function");
5803	}
5804
5805	/**
5806	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.12
5807	* <pre>{@code
5808	* DoStatement:
5809	* do Statement while ( Expression ) ;
5810	* }</pre>
5811	*/
5812	final public DoStmt DoStatement() throws ParseException {Expression condition;
5813	Statement body;
5814	JavaToken begin;
5815	jj_consume_token(DO);
5816	begin=token();
5817	body = Statement();
5818	jj_consume_token(WHILE);
5819	jj_consume_token(LPAREN);
5820	condition = Expression();
5821	jj_consume_token(RPAREN);
5822	jj_consume_token(SEMICOLON);
5823	{if ("" != null) return new DoStmt(range(begin, token()),body, condition);}
5824	throw new IllegalStateException ("Missing return statement in function");
5825	}
5826
5827	/**
5828	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.14
5829	* <pre>{@code
5830	* ForStatement:
5831	* BasicForStatement
5832	* EnhancedForStatement
5833	* ForStatementNoShortIf:
5834	* BasicForStatementNoShortIf
5835	* EnhancedForStatementNoShortIf
5836	* }</pre>
5837	*/
5838	final public Statement ForStatement() throws ParseException {VariableDeclarationExpr varExpr = null;
5839	Expression expr = null;
5840	NodeList<Expression> init = emptyNodeList();
5841	NodeList<Expression> update = emptyNodeList();
5842	Statement body;
5843	JavaToken begin;
5844	jj_consume_token(FOR);
5845	begin=token();
5846	jj_consume_token(LPAREN);
5847	if (jj_2_46(2147483647)) {
5848	varExpr = VariableDeclarationExpression();
5849	jj_consume_token(COLON);
5850	expr = Expression();
5851	} else {
5852	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5853	case ABSTRACT:
5854	case BOOLEAN:
5855	case BYTE:
5856	case CHAR:
5857	case _DEFAULT:
5858	case DOUBLE:
5859	case ENUM:
5860	case FALSE:
5861	case FINAL:
5862	case FLOAT:
5863	case INT:
5864	case LONG:
5865	case NATIVE:
5866	case NEW:
5867	case NULL:
5868	case PRIVATE:
5869	case PROTECTED:
5870	case PUBLIC:
5871	case SHORT:
5872	case STATIC:
5873	case STRICTFP:
5874	case SUPER:
5875	case SWITCH:
5876	case SYNCHRONIZED:
5877	case THIS:
5878	case TRANSIENT:
5879	case TRUE:
5880	case VOID:
5881	case VOLATILE:
5882	case YIELD:
5883	case REQUIRES:
5884	case TO:
5885	case WITH:
5886	case OPEN:
5887	case OPENS:
5888	case USES:
5889	case MODULE:
5890	case EXPORTS:
5891	case PROVIDES:
5892	case TRANSITIVE:
5893	case LONG_LITERAL:
5894	case INTEGER_LITERAL:
5895	case FLOATING_POINT_LITERAL:
5896	case CHARACTER_LITERAL:
5897	case STRING_LITERAL:
5898	case TEXT_BLOCK_LITERAL:
5899	case IDENTIFIER:
5900	case LPAREN:
5901	case SEMICOLON:
5902	case AT:
5903	case BANG:
5904	case TILDE:
5905	case INCR:
5906	case DECR:
5907	case PLUS:
5908	case MINUS:{
5909	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5910	case ABSTRACT:
5911	case BOOLEAN:
5912	case BYTE:
5913	case CHAR:
5914	case _DEFAULT:
5915	case DOUBLE:
5916	case ENUM:
5917	case FALSE:
5918	case FINAL:
5919	case FLOAT:
5920	case INT:
5921	case LONG:
5922	case NATIVE:
5923	case NEW:
5924	case NULL:
5925	case PRIVATE:
5926	case PROTECTED:
5927	case PUBLIC:
5928	case SHORT:
5929	case STATIC:
5930	case STRICTFP:
5931	case SUPER:
5932	case SWITCH:
5933	case SYNCHRONIZED:
5934	case THIS:
5935	case TRANSIENT:
5936	case TRUE:
5937	case VOID:
5938	case VOLATILE:
5939	case YIELD:
5940	case REQUIRES:
5941	case TO:
5942	case WITH:
5943	case OPEN:
5944	case OPENS:
5945	case USES:
5946	case MODULE:
5947	case EXPORTS:
5948	case PROVIDES:
5949	case TRANSITIVE:
5950	case LONG_LITERAL:
5951	case INTEGER_LITERAL:
5952	case FLOATING_POINT_LITERAL:
5953	case CHARACTER_LITERAL:
5954	case STRING_LITERAL:
5955	case TEXT_BLOCK_LITERAL:
5956	case IDENTIFIER:
5957	case LPAREN:
5958	case AT:
5959	case BANG:
5960	case TILDE:
5961	case INCR:
5962	case DECR:
5963	case PLUS:
5964	case MINUS:{
5965	init = ForInit();
5966	break;
5967	}
5968	default:
5969	jj_la1[136] = jj_gen;
5970	;
5971	}
5972	jj_consume_token(SEMICOLON);
5973	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
5974	case BOOLEAN:
5975	case BYTE:
5976	case CHAR:
5977	case DOUBLE:
5978	case ENUM:
5979	case FALSE:
5980	case FLOAT:
5981	case INT:
5982	case LONG:
5983	case NEW:
5984	case NULL:
5985	case SHORT:
5986	case STRICTFP:
5987	case SUPER:
5988	case SWITCH:
5989	case THIS:
5990	case TRUE:
5991	case VOID:
5992	case YIELD:
5993	case REQUIRES:
5994	case TO:
5995	case WITH:
5996	case OPEN:
5997	case OPENS:
5998	case USES:
5999	case MODULE:
6000	case EXPORTS:
6001	case PROVIDES:
6002	case TRANSITIVE:
6003	case LONG_LITERAL:
6004	case INTEGER_LITERAL:
6005	case FLOATING_POINT_LITERAL:
6006	case CHARACTER_LITERAL:
6007	case STRING_LITERAL:
6008	case TEXT_BLOCK_LITERAL:
6009	case IDENTIFIER:
6010	case LPAREN:
6011	case AT:
6012	case BANG:
6013	case TILDE:
6014	case INCR:
6015	case DECR:
6016	case PLUS:
6017	case MINUS:{
6018	expr = Expression();
6019	break;
6020	}
6021	default:
6022	jj_la1[137] = jj_gen;
6023	;
6024	}
6025	jj_consume_token(SEMICOLON);
6026	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6027	case BOOLEAN:
6028	case BYTE:
6029	case CHAR:
6030	case DOUBLE:
6031	case ENUM:
6032	case FALSE:
6033	case FLOAT:
6034	case INT:
6035	case LONG:
6036	case NEW:
6037	case NULL:
6038	case SHORT:
6039	case STRICTFP:
6040	case SUPER:
6041	case SWITCH:
6042	case THIS:
6043	case TRUE:
6044	case VOID:
6045	case YIELD:
6046	case REQUIRES:
6047	case TO:
6048	case WITH:
6049	case OPEN:
6050	case OPENS:
6051	case USES:
6052	case MODULE:
6053	case EXPORTS:
6054	case PROVIDES:
6055	case TRANSITIVE:
6056	case LONG_LITERAL:
6057	case INTEGER_LITERAL:
6058	case FLOATING_POINT_LITERAL:
6059	case CHARACTER_LITERAL:
6060	case STRING_LITERAL:
6061	case TEXT_BLOCK_LITERAL:
6062	case IDENTIFIER:
6063	case LPAREN:
6064	case AT:
6065	case BANG:
6066	case TILDE:
6067	case INCR:
6068	case DECR:
6069	case PLUS:
6070	case MINUS:{
6071	update = ForUpdate();
6072	break;
6073	}
6074	default:
6075	jj_la1[138] = jj_gen;
6076	;
6077	}
6078	break;
6079	}
6080	default:
6081	jj_la1[139] = jj_gen;
6082	jj_consume_token(-1);
6083	throw new ParseException();
6084	}
6085	}
6086	jj_consume_token(RPAREN);
6087	body = Statement();
6088	if (varExpr != null) {
6089	{if ("" != null) return new ForEachStmt(range(begin, token()),varExpr, expr, body);}
6090	}
6091	{if ("" != null) return new ForStmt(range(begin, token()),init, expr, update, body);}
6092	throw new IllegalStateException ("Missing return statement in function");
6093	}
6094
6095	/**
6096	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.14
6097	* <pre>{@code
6098	* BasicForStatement:
6099	* for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement
6100	* BasicForStatementNoShortIf:
6101	* for ( [ForInit] ; [Expression] ; [ForUpdate] ) StatementNoShortIf
6102	* ForInit:
6103	* StatementExpressionList
6104	* LocalVariableDeclaration
6105	* ForUpdate:
6106	* StatementExpressionList
6107	* StatementExpressionList:
6108	* StatementExpression {, StatementExpression}
6109	* }</pre>
6110	*/
6111	final public NodeList<Expression> ForInit() throws ParseException {NodeList<Expression> ret;
6112	Expression expr;
6113	if (jj_2_47(2147483647)) {
6114	expr = VariableDeclarationExpression();
6115	ret = new NodeList<Expression>(); ret.add(expr);
6116	} else {
6117	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6118	case BOOLEAN:
6119	case BYTE:
6120	case CHAR:
6121	case DOUBLE:
6122	case ENUM:
6123	case FALSE:
6124	case FLOAT:
6125	case INT:
6126	case LONG:
6127	case NEW:
6128	case NULL:
6129	case SHORT:
6130	case STRICTFP:
6131	case SUPER:
6132	case SWITCH:
6133	case THIS:
6134	case TRUE:
6135	case VOID:
6136	case YIELD:
6137	case REQUIRES:
6138	case TO:
6139	case WITH:
6140	case OPEN:
6141	case OPENS:
6142	case USES:
6143	case MODULE:
6144	case EXPORTS:
6145	case PROVIDES:
6146	case TRANSITIVE:
6147	case LONG_LITERAL:
6148	case INTEGER_LITERAL:
6149	case FLOATING_POINT_LITERAL:
6150	case CHARACTER_LITERAL:
6151	case STRING_LITERAL:
6152	case TEXT_BLOCK_LITERAL:
6153	case IDENTIFIER:
6154	case LPAREN:
6155	case AT:
6156	case BANG:
6157	case TILDE:
6158	case INCR:
6159	case DECR:
6160	case PLUS:
6161	case MINUS:{
6162	ret = ExpressionList();
6163	break;
6164	}
6165	default:
6166	jj_la1[140] = jj_gen;
6167	jj_consume_token(-1);
6168	throw new ParseException();
6169	}
6170	}
6171	{if ("" != null) return ret;}
6172	throw new IllegalStateException ("Missing return statement in function");
6173	}
6174
6175	/**
6176	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.14
6177	* <pre>{@code
6178	* BasicForStatement:
6179	* for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement
6180	* BasicForStatementNoShortIf:
6181	* for ( [ForInit] ; [Expression] ; [ForUpdate] ) StatementNoShortIf
6182	* ForInit:
6183	* StatementExpressionList
6184	* LocalVariableDeclaration
6185	* ForUpdate:
6186	* StatementExpressionList
6187	* StatementExpressionList:
6188	* StatementExpression {, StatementExpression}
6189	* }</pre>
6190	*/
6191	final public NodeList<Expression> ExpressionList() throws ParseException {NodeList<Expression> ret = new NodeList<Expression>();
6192	Expression expr;
6193	expr = Expression();
6194	ret.add(expr);
6195	label_47:
6196	while (true) {
6197	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6198	case COMMA:{
6199	break;
6200	}
6201	default:
6202	jj_la1[141] = jj_gen;
6203	break label_47;
6204	}
6205	jj_consume_token(COMMA);
6206	expr = Expression();
6207	ret.add(expr);
6208	}
6209	{if ("" != null) return ret;}
6210	throw new IllegalStateException ("Missing return statement in function");
6211	}
6212
6213	/**
6214	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.14
6215	* <pre>{@code
6216	* BasicForStatement:
6217	* for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement
6218	* BasicForStatementNoShortIf:
6219	* for ( [ForInit] ; [Expression] ; [ForUpdate] ) StatementNoShortIf
6220	* ForInit:
6221	* StatementExpressionList
6222	* LocalVariableDeclaration
6223	* ForUpdate:
6224	* StatementExpressionList
6225	* StatementExpressionList:
6226	* StatementExpression {, StatementExpression}
6227	* }</pre>
6228	*/
6229	final public NodeList<Expression> ForUpdate() throws ParseException {NodeList<Expression> ret;
6230	ret = ExpressionList();
6231	{if ("" != null) return ret;}
6232	throw new IllegalStateException ("Missing return statement in function");
6233	}
6234
6235	/**
6236	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.15
6237	* <pre>{@code
6238	* BreakStatement:
6239	* break [Identifier] ;
6240	* }</pre>
6241	*/
6242	final public BreakStmt BreakStatement() throws ParseException {SimpleName label = null;
6243	JavaToken begin;
6244	jj_consume_token(BREAK);
6245	begin=token();
6246	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6247	case ENUM:
6248	case STRICTFP:
6249	case YIELD:
6250	case REQUIRES:
6251	case TO:
6252	case WITH:
6253	case OPEN:
6254	case OPENS:
6255	case USES:
6256	case MODULE:
6257	case EXPORTS:
6258	case PROVIDES:
6259	case TRANSITIVE:
6260	case IDENTIFIER:{
6261	label = SimpleName();
6262	break;
6263	}
6264	default:
6265	jj_la1[142] = jj_gen;
6266	;
6267	}
6268	jj_consume_token(SEMICOLON);
6269	{if ("" != null) return new BreakStmt(range(begin, token()), label);}
6270	throw new IllegalStateException ("Missing return statement in function");
6271	}
6272
6273	/**
6274	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.21
6275	* <pre>{@code
6276	* YieldStatement:
6277	* yield Expression ;
6278	* }</pre>
6279	*/
6280	final public YieldStmt YieldStatement() throws ParseException {Expression value;
6281	JavaToken begin;
6282	jj_consume_token(YIELD);
6283	begin=token();
6284	value = Expression();
6285	jj_consume_token(SEMICOLON);
6286	{if ("" != null) return new YieldStmt(range(begin, token()), value);}
6287	throw new IllegalStateException ("Missing return statement in function");
6288	}
6289
6290	/**
6291	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.16
6292	* <pre>{@code
6293	* ContinueStatement:
6294	* continue [Identifier] ;
6295	* }</pre>
6296	*/
6297	final public ContinueStmt ContinueStatement() throws ParseException {SimpleName label = null;
6298	JavaToken begin;
6299	jj_consume_token(CONTINUE);
6300	begin=token();
6301	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6302	case ENUM:
6303	case STRICTFP:
6304	case YIELD:
6305	case REQUIRES:
6306	case TO:
6307	case WITH:
6308	case OPEN:
6309	case OPENS:
6310	case USES:
6311	case MODULE:
6312	case EXPORTS:
6313	case PROVIDES:
6314	case TRANSITIVE:
6315	case IDENTIFIER:{
6316	label = SimpleName();
6317	break;
6318	}
6319	default:
6320	jj_la1[143] = jj_gen;
6321	;
6322	}
6323	jj_consume_token(SEMICOLON);
6324	{if ("" != null) return new ContinueStmt(range(begin, token()), label);}
6325	throw new IllegalStateException ("Missing return statement in function");
6326	}
6327
6328	/**
6329	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.17
6330	* <pre>{@code
6331	* ReturnStatement:
6332	* return [Expression] ;
6333	* }</pre>
6334	*/
6335	final public ReturnStmt ReturnStatement() throws ParseException {Expression expr = null;
6336	JavaToken begin;
6337	jj_consume_token(RETURN);
6338	begin=token();
6339	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6340	case BOOLEAN:
6341	case BYTE:
6342	case CHAR:
6343	case DOUBLE:
6344	case ENUM:
6345	case FALSE:
6346	case FLOAT:
6347	case INT:
6348	case LONG:
6349	case NEW:
6350	case NULL:
6351	case SHORT:
6352	case STRICTFP:
6353	case SUPER:
6354	case SWITCH:
6355	case THIS:
6356	case TRUE:
6357	case VOID:
6358	case YIELD:
6359	case REQUIRES:
6360	case TO:
6361	case WITH:
6362	case OPEN:
6363	case OPENS:
6364	case USES:
6365	case MODULE:
6366	case EXPORTS:
6367	case PROVIDES:
6368	case TRANSITIVE:
6369	case LONG_LITERAL:
6370	case INTEGER_LITERAL:
6371	case FLOATING_POINT_LITERAL:
6372	case CHARACTER_LITERAL:
6373	case STRING_LITERAL:
6374	case TEXT_BLOCK_LITERAL:
6375	case IDENTIFIER:
6376	case LPAREN:
6377	case AT:
6378	case BANG:
6379	case TILDE:
6380	case INCR:
6381	case DECR:
6382	case PLUS:
6383	case MINUS:{
6384	expr = Expression();
6385	break;
6386	}
6387	default:
6388	jj_la1[144] = jj_gen;
6389	;
6390	}
6391	jj_consume_token(SEMICOLON);
6392	{if ("" != null) return new ReturnStmt(range(begin, token()),expr);}
6393	throw new IllegalStateException ("Missing return statement in function");
6394	}
6395
6396	/**
6397	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.18
6398	* <pre>{@code
6399	* ThrowStatement:
6400	* throw Expression ;
6401	* }</pre>
6402	*/
6403	final public ThrowStmt ThrowStatement() throws ParseException {Expression expr;
6404	JavaToken begin;
6405	jj_consume_token(THROW);
6406	begin=token();
6407	expr = Expression();
6408	jj_consume_token(SEMICOLON);
6409	{if ("" != null) return new ThrowStmt(range(begin, token()),expr);}
6410	throw new IllegalStateException ("Missing return statement in function");
6411	}
6412
6413	/**
6414	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.19
6415	* <pre>{@code
6416	* SynchronizedStatement:
6417	* synchronized ( Expression ) Block
6418	* }</pre>
6419	*/
6420	final public SynchronizedStmt SynchronizedStatement() throws ParseException {Expression expr;
6421	BlockStmt body;
6422	JavaToken begin;
6423	jj_consume_token(SYNCHRONIZED);
6424	begin=token();
6425	jj_consume_token(LPAREN);
6426	expr = Expression();
6427	jj_consume_token(RPAREN);
6428	body = Block();
6429	{if ("" != null) return new SynchronizedStmt(range(begin, token()),expr, body);}
6430	throw new IllegalStateException ("Missing return statement in function");
6431	}
6432
6433	/**
6434	* // TODO: Examine more closely.
6435	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.20
6436	* <pre>{@code
6437	* TryStatement:
6438	* try Block Catches
6439	* try Block [Catches] Finally
6440	* TryWithResourcesStatement
6441	* Catches:
6442	* CatchClause {CatchClause}
6443	* CatchClause:
6444	* catch ( CatchFormalParameter ) Block
6445	* CatchFormalParameter:
6446	* {VariableModifier} CatchType VariableDeclaratorId
6447	* CatchType:
6448	* UnannClassType {\| ClassType}
6449	* Finally:
6450	* finally Block
6451	* }<pre>
6452	* For Convenience:
6453	* <pre>{@code
6454	* VariableModifier:
6455	* Annotation
6456	* final
6457	* VariableDeclaratorId:
6458	* Identifier [Dims]
6459	* Dims:
6460	* {Annotation} [ ] {{Annotation} [ ]}
6461	* }<pre>
6462	*/
6463	final public TryStmt TryStatement() throws ParseException {NodeList<Expression> resources = emptyNodeList();
6464	BlockStmt tryBlock;
6465	BlockStmt finallyBlock = null;
6466	NodeList<CatchClause> catchs = emptyNodeList();
6467	BlockStmt catchBlock;
6468	ModifierHolder exceptModifier;
6469	ReferenceType exceptionType;
6470	NodeList<ReferenceType> exceptionTypes = emptyNodeList();
6471	Pair<SimpleName, List<ArrayBracketPair>> exceptId;
6472	JavaToken begin;
6473	JavaToken catchBegin;
6474	JavaToken typesBegin;
6475	JavaToken paramEnd;
6476	Type type;
6477	jj_consume_token(TRY);
6478	begin=token();
6479	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6480	case LPAREN:{
6481	resources = ResourceSpecification();
6482	break;
6483	}
6484	default:
6485	jj_la1[145] = jj_gen;
6486	;
6487	}
6488	tryBlock = Block();
6489	label_48:
6490	while (true) {
6491	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6492	case CATCH:{
6493	break;
6494	}
6495	default:
6496	jj_la1[146] = jj_gen;
6497	break label_48;
6498	}
6499	jj_consume_token(CATCH);
6500	catchBegin=token();
6501	jj_consume_token(LPAREN);
6502	exceptModifier = Modifiers();
6503	typesBegin = exceptModifier.begin;
6504	exceptionType = ReferenceType(emptyNodeList());
6505	exceptionTypes.add(exceptionType); typesBegin = orIfInvalid(typesBegin, token());
6506	label_49:
6507	while (true) {
6508	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6509	case BIT_OR:{
6510	break;
6511	}
6512	default:
6513	jj_la1[147] = jj_gen;
6514	break label_49;
6515	}
6516	jj_consume_token(BIT_OR);
6517	exceptionType = AnnotatedReferenceType();
6518	exceptionTypes.add(exceptionType);
6519	}
6520	exceptId = VariableDeclaratorId();
6521	paramEnd = token();
6522	jj_consume_token(RPAREN);
6523	catchBlock = Block();
6524	if (exceptionTypes.size() > 1) {
6525	type = new UnionType(range(exceptionTypes.get(0), exceptionTypes.get(exceptionTypes.size() - 1)), exceptionTypes);
6526	} else {
6527	type = (Type)exceptionTypes.get(0);
6528	}
6529	Parameter catchType = new Parameter(range(typesBegin, paramEnd), exceptModifier.modifiers, exceptModifier.annotations, type, false, emptyNodeList(), exceptId.a);
6530	catchs = add(catchs, new CatchClause(range(catchBegin, token()), catchType, catchBlock));
6531	exceptionTypes = emptyNodeList();
6532	}
6533	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6534	case FINALLY:{
6535	jj_consume_token(FINALLY);
6536	finallyBlock = Block();
6537	break;
6538	}
6539	default:
6540	jj_la1[148] = jj_gen;
6541	;
6542	}
6543	{if ("" != null) return new TryStmt(range(begin, token()), resources, tryBlock, catchs, finallyBlock);}
6544	throw new IllegalStateException ("Missing return statement in function");
6545	}
6546
6547	/**
6548	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.20.3
6549	* <pre>{@code
6550	* TryWithResourcesStatement:
6551	* try ResourceSpecification Block [Catches] [Finally]
6552	* ResourceSpecification:
6553	* ( ResourceList [;] )
6554	* ResourceList:
6555	* Resource {; Resource}
6556	* Resource:
6557	* {VariableModifier} LocalVariableType Identifier = Expression
6558	* VariableAccess
6559	* VariableAccess:
6560	* ExpressionName
6561	* FieldAccess
6562	* }<pre>
6563	* For Convenience:
6564	* <pre>{@code
6565	* VariableModifier:
6566	* Annotation
6567	* final
6568	* LocalVariableType:
6569	* UnannType
6570	* var
6571	* }<pre>
6572	*/
6573	final public NodeList<Expression> ResourceSpecification() throws ParseException {NodeList<Expression> variables;
6574	jj_consume_token(LPAREN);
6575	variables = Resources();
6576	if (jj_2_48(2)) {
6577	jj_consume_token(SEMICOLON);
6578	} else {
6579	;
6580	}
6581	jj_consume_token(RPAREN);
6582	{if ("" != null) return variables;}
6583	throw new IllegalStateException ("Missing return statement in function");
6584	}
6585
6586	/**
6587	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.20.3
6588	* <pre>{@code
6589	* ResourceList:
6590	* Resource {; Resource}
6591	* Resource:
6592	* {VariableModifier} LocalVariableType Identifier = Expression
6593	* VariableAccess
6594	* VariableAccess:
6595	* ExpressionName
6596	* FieldAccess
6597	* }<pre>
6598	* For Convenience:
6599	* <pre>{@code
6600	* VariableModifier:
6601	* Annotation
6602	* final
6603	* LocalVariableType:
6604	* UnannType
6605	* var
6606	* }<pre>
6607	*/
6608	final public NodeList<Expression> Resources() throws ParseException {NodeList<Expression> expressions = new NodeList<Expression>();
6609	Expression expr;
6610	expr = Resource();
6611	expressions.add(expr);
6612	label_50:
6613	while (true) {
6614	if (jj_2_49(2)) {
6615	} else {
6616	break label_50;
6617	}
6618	jj_consume_token(SEMICOLON);
6619	expr = Resource();
6620	expressions.add(expr);
6621	}
6622	{if ("" != null) return expressions;}
6623	throw new IllegalStateException ("Missing return statement in function");
6624	}
6625
6626	/**
6627	* // TODO: Examine more closely.
6628	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-14.html#jls-14.20.3
6629	* <pre>{@code
6630	* Resource:
6631	* {VariableModifier} LocalVariableType Identifier = Expression
6632	* VariableAccess
6633	* VariableAccess:
6634	* ExpressionName
6635	* FieldAccess
6636	* }<pre>
6637	* For Convenience:
6638	* <pre>{@code
6639	* VariableModifier:
6640	* Annotation
6641	* final
6642	* LocalVariableType:
6643	* UnannType
6644	* var
6645	* }<pre>
6646	*/
6647	final public Expression Resource() throws ParseException {Expression expr;
6648	if (jj_2_50(2147483647)) {
6649	/this is a bit more lenient than we need to be, e.g. allowing access modifiers like private/
6650	expr = VariableDeclarationExpression();
6651	} else {
6652	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6653	case BOOLEAN:
6654	case BYTE:
6655	case CHAR:
6656	case DOUBLE:
6657	case ENUM:
6658	case FALSE:
6659	case FLOAT:
6660	case INT:
6661	case LONG:
6662	case NEW:
6663	case NULL:
6664	case SHORT:
6665	case STRICTFP:
6666	case SUPER:
6667	case THIS:
6668	case TRUE:
6669	case VOID:
6670	case YIELD:
6671	case REQUIRES:
6672	case TO:
6673	case WITH:
6674	case OPEN:
6675	case OPENS:
6676	case USES:
6677	case MODULE:
6678	case EXPORTS:
6679	case PROVIDES:
6680	case TRANSITIVE:
6681	case LONG_LITERAL:
6682	case INTEGER_LITERAL:
6683	case FLOATING_POINT_LITERAL:
6684	case CHARACTER_LITERAL:
6685	case STRING_LITERAL:
6686	case TEXT_BLOCK_LITERAL:
6687	case IDENTIFIER:
6688	case LPAREN:
6689	case AT:{
6690	expr = PrimaryExpression();
6691	break;
6692	}
6693	default:
6694	jj_la1[149] = jj_gen;
6695	jj_consume_token(-1);
6696	throw new ParseException();
6697	}
6698	}
6699	{if ("" != null) return expr;}
6700	throw new IllegalStateException ("Missing return statement in function");
6701	}
6702
6703	/* We use productions to match >>>, >> and > so that we can keep the
6704	* type declaration syntax with generics clean
6705	*/
6706	final public
6707	void RUNSIGNEDSHIFT() throws ParseException {
6708	if (getToken(1).kind == GT && getToken(1).realKind == RUNSIGNEDSHIFT) {
6709
6710	} else {
6711	jj_consume_token(-1);
6712	throw new ParseException();
6713	}
6714	jj_consume_token(GT);
6715	jj_consume_token(GT);
6716	jj_consume_token(GT);
6717	}
6718
6719	final public void RSIGNEDSHIFT() throws ParseException {
6720	if (getToken(1).kind == GT && getToken(1).realKind == RSIGNEDSHIFT) {
6721
6722	} else {
6723	jj_consume_token(-1);
6724	throw new ParseException();
6725	}
6726	jj_consume_token(GT);
6727	jj_consume_token(GT);
6728	}
6729
6730	/* Annotation syntax follows. */
6731
6732	/**
6733	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7
6734	* <pre>{@code
6735	* Annotation:
6736	* NormalAnnotation
6737	* MarkerAnnotation
6738	* SingleElementAnnotation
6739	* }<pre>
6740	*/
6741	final public NodeList<AnnotationExpr> Annotations() throws ParseException {NodeList<AnnotationExpr> annotations = new NodeList<AnnotationExpr>();
6742	AnnotationExpr annotation;
6743	label_51:
6744	while (true) {
6745	if (jj_2_51(2147483647)) {
6746	} else {
6747	break label_51;
6748	}
6749	annotation = Annotation();
6750	annotations = add(annotations, annotation);
6751	}
6752	{if ("" != null) return annotations;}
6753	throw new IllegalStateException ("Missing return statement in function");
6754	}
6755
6756	/**
6757	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7
6758	* <pre>{@code
6759	* Annotation:
6760	* NormalAnnotation
6761	* MarkerAnnotation
6762	* SingleElementAnnotation
6763	* }<pre>
6764	* For Convenience:
6765	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7.1
6766	* <pre>{@code
6767	* NormalAnnotation:
6768	* @ TypeName ( [ElementValuePairList] )
6769	* ElementValuePairList:
6770	* ElementValuePair {, ElementValuePair}
6771	* ElementValuePair:
6772	* Identifier = ElementValue
6773	* ElementValue:
6774	* ConditionalExpression
6775	* ElementValueArrayInitializer
6776	* Annotation
6777	* ElementValueArrayInitializer:
6778	* { [ElementValueList] [,] }
6779	* ElementValueList:
6780	* ElementValue {, ElementValue}
6781	* }<pre>
6782	* For Convenience:
6783	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7.2
6784	* <blockquote>
6785	* It [The marker annotation] is shorthand for the normal annotation:
6786	* {@code @TypeName()}
6787	* </blockquote>
6788	* <pre>{@code
6789	* MarkerAnnotation:
6790	* @ TypeName
6791	* }<pre>
6792	* For Convenience:
6793	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7.3
6794	* <blockquote>
6795	* It [The single element annotation] is shorthand for the normal annotation:
6796	* {@code @TypeName(value = ElementValue)}
6797	* </blockquote>
6798	* <pre>{@code
6799	* SingleElementAnnotation:
6800	* @ TypeName ( ElementValue )
6801	* }<pre>
6802	*/
6803	final public AnnotationExpr Annotation() throws ParseException {AnnotationExpr ret;
6804	Name name;
6805	NodeList<MemberValuePair> pairs = emptyNodeList();
6806	JavaToken begin;
6807	Expression memberVal;
6808	jj_consume_token(AT);
6809	begin=token();
6810	name = Name();
6811	if (jj_2_52(2147483647)) {
6812	jj_consume_token(LPAREN);
6813	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6814	case ENUM:
6815	case STRICTFP:
6816	case YIELD:
6817	case REQUIRES:
6818	case TO:
6819	case WITH:
6820	case OPEN:
6821	case OPENS:
6822	case USES:
6823	case MODULE:
6824	case EXPORTS:
6825	case PROVIDES:
6826	case TRANSITIVE:
6827	case IDENTIFIER:{
6828	pairs = MemberValuePairs();
6829	break;
6830	}
6831	default:
6832	jj_la1[150] = jj_gen;
6833	;
6834	}
6835	jj_consume_token(RPAREN);
6836	ret = new NormalAnnotationExpr(range(begin, token()), name, pairs);
6837	} else if (jj_2_53(2147483647)) {
6838	jj_consume_token(LPAREN);
6839	memberVal = MemberValue();
6840	jj_consume_token(RPAREN);
6841	ret = new SingleMemberAnnotationExpr(range(begin, token()), name, memberVal);
6842	} else {
6843	ret = new MarkerAnnotationExpr(range(begin, token()), name);
6844	}
6845	{if ("" != null) return ret;}
6846	throw new IllegalStateException ("Missing return statement in function");
6847	}
6848
6849	/**
6850	* Note that {@code MemberValuePairs} (JavaParser) is synonymous with {@code ElementValuePairList} (JLS)
6851	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7.1
6852	* <pre>{@code
6853	* NormalAnnotation:
6854	* @ TypeName ( [ElementValuePairList] )
6855	* ElementValuePairList:
6856	* ElementValuePair {, ElementValuePair}
6857	* ElementValuePair:
6858	* Identifier = ElementValue
6859	* }<pre>
6860	*/
6861	final public NodeList<MemberValuePair> MemberValuePairs() throws ParseException {NodeList<MemberValuePair> ret = new NodeList<MemberValuePair>();
6862	MemberValuePair pair;
6863	pair = MemberValuePair();
6864	ret.add(pair);
6865	label_52:
6866	while (true) {
6867	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6868	case COMMA:{
6869	break;
6870	}
6871	default:
6872	jj_la1[151] = jj_gen;
6873	break label_52;
6874	}
6875	jj_consume_token(COMMA);
6876	pair = MemberValuePair();
6877	ret.add(pair);
6878	}
6879	{if ("" != null) return ret;}
6880	throw new IllegalStateException ("Missing return statement in function");
6881	}
6882
6883	/**
6884	* Note that {@code MemberValuePair} (JavaParser) is synonymous with {@code ElementValuePair} (JLS)
6885	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7.1
6886	* <pre>{@code
6887	* ElementValuePair:
6888	* Identifier = ElementValue
6889	* ElementValue:
6890	* ConditionalExpression
6891	* ElementValueArrayInitializer
6892	* Annotation
6893	* ElementValueArrayInitializer:
6894	* { [ElementValueList] [,] }
6895	* ElementValueList:
6896	* ElementValue {, ElementValue}
6897	* }<pre>
6898	*/
6899	final public MemberValuePair MemberValuePair() throws ParseException {SimpleName name;
6900	Expression value;
6901	JavaToken begin;
6902	name = SimpleName();
6903	begin=token();
6904	jj_consume_token(ASSIGN);
6905	value = MemberValue();
6906	{if ("" != null) return new MemberValuePair(range(begin, token()),name, value);}
6907	throw new IllegalStateException ("Missing return statement in function");
6908	}
6909
6910	/**
6911	* Note that {@code MemberValue} (JavaParser) is synonymous with {@code ElementValue} (JLS)
6912	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7.1
6913	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-ElementValue
6914	* <pre>{@code
6915	* ElementValue:
6916	* ConditionalExpression
6917	* ElementValueArrayInitializer
6918	* Annotation
6919	* ElementValueArrayInitializer:
6920	* { [ElementValueList] [,] }
6921	* ElementValueList:
6922	* ElementValue {, ElementValue}
6923	* }<pre>
6924	*/
6925	final public Expression MemberValue() throws ParseException {Expression ret;
6926	if (jj_2_54(2147483647)) {
6927	ret = Annotation();
6928	} else {
6929	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
6930	case LBRACE:{
6931	ret = MemberValueArrayInitializer();
6932	break;
6933	}
6934	case BOOLEAN:
6935	case BYTE:
6936	case CHAR:
6937	case DOUBLE:
6938	case ENUM:
6939	case FALSE:
6940	case FLOAT:
6941	case INT:
6942	case LONG:
6943	case NEW:
6944	case NULL:
6945	case SHORT:
6946	case STRICTFP:
6947	case SUPER:
6948	case SWITCH:
6949	case THIS:
6950	case TRUE:
6951	case VOID:
6952	case YIELD:
6953	case REQUIRES:
6954	case TO:
6955	case WITH:
6956	case OPEN:
6957	case OPENS:
6958	case USES:
6959	case MODULE:
6960	case EXPORTS:
6961	case PROVIDES:
6962	case TRANSITIVE:
6963	case LONG_LITERAL:
6964	case INTEGER_LITERAL:
6965	case FLOATING_POINT_LITERAL:
6966	case CHARACTER_LITERAL:
6967	case STRING_LITERAL:
6968	case TEXT_BLOCK_LITERAL:
6969	case IDENTIFIER:
6970	case LPAREN:
6971	case AT:
6972	case BANG:
6973	case TILDE:
6974	case INCR:
6975	case DECR:
6976	case PLUS:
6977	case MINUS:{
6978	ret = ConditionalExpression();
6979	break;
6980	}
6981	default:
6982	jj_la1[152] = jj_gen;
6983	jj_consume_token(-1);
6984	throw new ParseException();
6985	}
6986	}
6987	{if ("" != null) return ret;}
6988	throw new IllegalStateException ("Missing return statement in function");
6989	}
6990
6991	/**
6992	* Note that {@code MemberValueArrayInitializer} (JavaParser) is synonymous with {@code ElementValueArrayInitializer} (JLS)
6993	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7.1
6994	* <pre>{@code
6995	* ElementValueArrayInitializer:
6996	* { [ElementValueList] [,] }
6997	* ElementValueList:
6998	* ElementValue {, ElementValue}
6999	* }<pre>
7000	*/
7001	final public Expression MemberValueArrayInitializer() throws ParseException {NodeList<Expression> ret = emptyNodeList();
7002	Expression member;
7003	JavaToken begin;
7004	jj_consume_token(LBRACE);
7005	begin=token();
7006	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7007	case BOOLEAN:
7008	case BYTE:
7009	case CHAR:
7010	case DOUBLE:
7011	case ENUM:
7012	case FALSE:
7013	case FLOAT:
7014	case INT:
7015	case LONG:
7016	case NEW:
7017	case NULL:
7018	case SHORT:
7019	case STRICTFP:
7020	case SUPER:
7021	case SWITCH:
7022	case THIS:
7023	case TRUE:
7024	case VOID:
7025	case YIELD:
7026	case REQUIRES:
7027	case TO:
7028	case WITH:
7029	case OPEN:
7030	case OPENS:
7031	case USES:
7032	case MODULE:
7033	case EXPORTS:
7034	case PROVIDES:
7035	case TRANSITIVE:
7036	case LONG_LITERAL:
7037	case INTEGER_LITERAL:
7038	case FLOATING_POINT_LITERAL:
7039	case CHARACTER_LITERAL:
7040	case STRING_LITERAL:
7041	case TEXT_BLOCK_LITERAL:
7042	case IDENTIFIER:
7043	case LPAREN:
7044	case LBRACE:
7045	case AT:
7046	case BANG:
7047	case TILDE:
7048	case INCR:
7049	case DECR:
7050	case PLUS:
7051	case MINUS:{
7052	member = MemberValue();
7053	ret.add(member);
7054	label_53:
7055	while (true) {
7056	if (jj_2_55(2)) {
7057	} else {
7058	break label_53;
7059	}
7060	jj_consume_token(COMMA);
7061	member = MemberValue();
7062	ret.add(member);
7063	}
7064	break;
7065	}
7066	default:
7067	jj_la1[153] = jj_gen;
7068	;
7069	}
7070	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7071	case COMMA:{
7072	jj_consume_token(COMMA);
7073	break;
7074	}
7075	default:
7076	jj_la1[154] = jj_gen;
7077	;
7078	}
7079	jj_consume_token(RBRACE);
7080	{if ("" != null) return new ArrayInitializerExpr(range(begin, token()),ret);}
7081	throw new IllegalStateException ("Missing return statement in function");
7082	}
7083
7084	/* Annotation Types. */
7085
7086	/**
7087	* <blockquote>
7088	* An annotation type declaration specifies a new annotation type, a special kind of interface type.
7089	* To distinguish an annotation type declaration from a normal interface declaration, the keyword interface is preceded by an at-sign (@).
7090	* </blockquote>
7091	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.6
7092	* <pre>{@code
7093	* AnnotationTypeDeclaration:
7094	* {InterfaceModifier} @ interface TypeIdentifier AnnotationTypeBody
7095	* }<pre>
7096	*/
7097	final public AnnotationDeclaration AnnotationTypeDeclaration(ModifierHolder modifier) throws ParseException {SimpleName name;
7098	NodeList<BodyDeclaration<?>> members = emptyNodeList();
7099	JavaToken begin = modifier.begin;
7100	jj_consume_token(AT);
7101	begin=orIfInvalid(begin, token());
7102	jj_consume_token(INTERFACE);
7103	name = SimpleName();
7104	members = AnnotationTypeBody();
7105	{if ("" != null) return new AnnotationDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, name, members);}
7106	throw new IllegalStateException ("Missing return statement in function");
7107	}
7108
7109	/**
7110	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.6.1
7111	* <pre>{@code
7112	* AnnotationTypeBody:
7113	* { {AnnotationTypeMemberDeclaration} }
7114	* AnnotationTypeMemberDeclaration:
7115	* AnnotationTypeElementDeclaration
7116	* ConstantDeclaration
7117	* ClassDeclaration
7118	* InterfaceDeclaration
7119	* ;
7120	* }<pre>
7121	*/
7122	final public NodeList<BodyDeclaration<?>> AnnotationTypeBody() throws ParseException {NodeList<BodyDeclaration<?>> ret = emptyNodeList();
7123	BodyDeclaration member;
7124	jj_consume_token(LBRACE);
7125	label_54:
7126	while (true) {
7127	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7128	case ABSTRACT:
7129	case BOOLEAN:
7130	case BYTE:
7131	case CHAR:
7132	case CLASS:
7133	case _DEFAULT:
7134	case DOUBLE:
7135	case ENUM:
7136	case FINAL:
7137	case FLOAT:
7138	case INT:
7139	case INTERFACE:
7140	case LONG:
7141	case NATIVE:
7142	case PRIVATE:
7143	case PROTECTED:
7144	case PUBLIC:
7145	case SHORT:
7146	case STATIC:
7147	case STRICTFP:
7148	case SYNCHRONIZED:
7149	case TRANSIENT:
7150	case VOLATILE:
7151	case YIELD:
7152	case REQUIRES:
7153	case TO:
7154	case WITH:
7155	case OPEN:
7156	case OPENS:
7157	case USES:
7158	case MODULE:
7159	case EXPORTS:
7160	case PROVIDES:
7161	case TRANSITIVE:
7162	case IDENTIFIER:
7163	case SEMICOLON:
7164	case AT:{
7165	break;
7166	}
7167	default:
7168	jj_la1[155] = jj_gen;
7169	break label_54;
7170	}
7171	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7172	case ABSTRACT:
7173	case BOOLEAN:
7174	case BYTE:
7175	case CHAR:
7176	case CLASS:
7177	case _DEFAULT:
7178	case DOUBLE:
7179	case ENUM:
7180	case FINAL:
7181	case FLOAT:
7182	case INT:
7183	case INTERFACE:
7184	case LONG:
7185	case NATIVE:
7186	case PRIVATE:
7187	case PROTECTED:
7188	case PUBLIC:
7189	case SHORT:
7190	case STATIC:
7191	case STRICTFP:
7192	case SYNCHRONIZED:
7193	case TRANSIENT:
7194	case VOLATILE:
7195	case YIELD:
7196	case REQUIRES:
7197	case TO:
7198	case WITH:
7199	case OPEN:
7200	case OPENS:
7201	case USES:
7202	case MODULE:
7203	case EXPORTS:
7204	case PROVIDES:
7205	case TRANSITIVE:
7206	case IDENTIFIER:
7207	case AT:{
7208	member = AnnotationBodyDeclaration();
7209	ret = addWhenNotNull(ret, member);
7210	break;
7211	}
7212	case SEMICOLON:{
7213	jj_consume_token(SEMICOLON);
7214	break;
7215	}
7216	default:
7217	jj_la1[156] = jj_gen;
7218	jj_consume_token(-1);
7219	throw new ParseException();
7220	}
7221	}
7222	jj_consume_token(RBRACE);
7223	{if ("" != null) return ret;}
7224	throw new IllegalStateException ("Missing return statement in function");
7225	}
7226
7227	/**
7228	* Note that {@code AnnotationTypeMemberDeclaration} (JLS) and {@code AnnotationBodyDeclaration} (JavaParser) are synonymous.
7229	https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.6.1
7230	* <pre>{@code
7231	* AnnotationTypeBody:
7232	* { {AnnotationTypeMemberDeclaration} }
7233	* AnnotationTypeMemberDeclaration:
7234	* AnnotationTypeElementDeclaration
7235	* ConstantDeclaration
7236	* ClassDeclaration
7237	* InterfaceDeclaration
7238	* ;
7239	* AnnotationTypeElementDeclaration:
7240	* {AnnotationTypeElementModifier} UnannType Identifier ( ) [Dims] [DefaultValue] ;
7241	* AnnotationTypeElementModifier:
7242	* (one of)
7243	* Annotation public
7244	* abstract
7245	* }<pre>
7246	* For Convenience:
7247	* <pre>{@code
7248	* Dims:
7249	* {Annotation} [ ] {{Annotation} [ ]}
7250	* }<pre>
7251	*/
7252	final public BodyDeclaration<?> AnnotationBodyDeclaration() throws ParseException {ModifierHolder modifier;
7253	BodyDeclaration ret;
7254	modifier = Modifiers();
7255	if (jj_2_56(2147483647)) {
7256	ret = AnnotationTypeMemberDeclaration(modifier);
7257	} else {
7258	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7259	case CLASS:
7260	case INTERFACE:{
7261	ret = ClassOrInterfaceDeclaration(modifier);
7262	break;
7263	}
7264	default:
7265	jj_la1[157] = jj_gen;
7266	if (jj_2_57(2147483647)) {
7267	ret = EnumDeclaration(modifier);
7268	} else {
7269	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7270	case AT:{
7271	ret = AnnotationTypeDeclaration(modifier);
7272	break;
7273	}
7274	case BOOLEAN:
7275	case BYTE:
7276	case CHAR:
7277	case DOUBLE:
7278	case ENUM:
7279	case FLOAT:
7280	case INT:
7281	case LONG:
7282	case SHORT:
7283	case STRICTFP:
7284	case YIELD:
7285	case REQUIRES:
7286	case TO:
7287	case WITH:
7288	case OPEN:
7289	case OPENS:
7290	case USES:
7291	case MODULE:
7292	case EXPORTS:
7293	case PROVIDES:
7294	case TRANSITIVE:
7295	case IDENTIFIER:{
7296	ret = FieldDeclaration(modifier);
7297	break;
7298	}
7299	default:
7300	jj_la1[158] = jj_gen;
7301	jj_consume_token(-1);
7302	throw new ParseException();
7303	}
7304	}
7305	}
7306	}
7307	{if ("" != null) return ret;}
7308	throw new IllegalStateException ("Missing return statement in function");
7309	}
7310
7311	/**
7312	* Note that {@code AnnotationTypeElementDeclaration} (JLS) and {@code AnnotationTypeMemberDeclaration} (JavaParser) are synonymous.
7313	* // TODO/FIXME: Consider missing `[Dims] (present in the JLS, but not the JavaParser grammar)
7314	* // TODO/FIXME: {AnnotationTypeElementModifier} UnannType Identifier ( ) [Dims] [DefaultValue] ;
7315	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.6.1
7316	* <pre>{@code
7317	* AnnotationTypeElementDeclaration:
7318	* {AnnotationTypeElementModifier} UnannType Identifier ( ) [Dims] [DefaultValue] ;
7319	* AnnotationTypeElementModifier:
7320	* (one of)
7321	* Annotation public
7322	* abstract
7323	* }<pre>
7324	* For Convenience:
7325	* <pre>{@code
7326	* Dims:
7327	* {Annotation} [ ] {{Annotation} [ ]}
7328	* }<pre>
7329	*/
7330	final public AnnotationMemberDeclaration AnnotationTypeMemberDeclaration(ModifierHolder modifier) throws ParseException {Type type;
7331	SimpleName name;
7332	Expression defaultVal = null;
7333	// TODO/FIXME: Consider missing `[Dims] (present in the JLS, but not the JavaParser grammar)
7334	// TODO/FIXME: {AnnotationTypeElementModifier} UnannType Identifier ( ) [Dims] [DefaultValue] ;
7335	type = Type(emptyNodeList());
7336	name = SimpleName();
7337	jj_consume_token(LPAREN);
7338	jj_consume_token(RPAREN);
7339	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7340	case _DEFAULT:{
7341	defaultVal = DefaultValue();
7342	break;
7343	}
7344	default:
7345	jj_la1[159] = jj_gen;
7346	;
7347	}
7348	jj_consume_token(SEMICOLON);
7349	JavaToken begin = orIfInvalid(modifier.begin, type);
7350	{if ("" != null) return new AnnotationMemberDeclaration(range(begin, token()), modifier.modifiers, modifier.annotations, type, name, defaultVal);}
7351	throw new IllegalStateException ("Missing return statement in function");
7352	}
7353
7354	/**
7355	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.6.2
7356	* <pre>{@code
7357	* DefaultValue:
7358	* default ElementValue
7359	* }<pre>
7360	* For Convenience:
7361	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-9.7.1
7362	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-9.html#jls-ElementValue
7363	* <pre>{@code
7364	* ElementValue:
7365	* ConditionalExpression
7366	* ElementValueArrayInitializer
7367	* Annotation
7368	* ElementValueArrayInitializer:
7369	* { [ElementValueList] [,] }
7370	* ElementValueList:
7371	* ElementValue {, ElementValue}
7372	* }<pre>
7373	*/
7374	final public Expression DefaultValue() throws ParseException {Expression ret;
7375	jj_consume_token(_DEFAULT);
7376	ret = MemberValue();
7377	{if ("" != null) return ret;}
7378	throw new IllegalStateException ("Missing return statement in function");
7379	}
7380
7381	/* Module syntax follows */
7382
7383
7384	/**
7385	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-7.html#jls-ModuleDirective
7386	* <pre>{@code
7387	* ModuleDirective:
7388	* requires {RequiresModifier} ModuleName ;
7389	* exports PackageName [to ModuleName {, ModuleName}] ;
7390	* opens PackageName [to ModuleName {, ModuleName}] ;
7391	* uses TypeName ;
7392	* provides TypeName with TypeName {, TypeName} ;
7393	* RequiresModifier:
7394	* (one of)
7395	* transitive static
7396	* }<pre>
7397	*/
7398	final public ModuleDirective ModuleDirective() throws ParseException {ModifierHolder modifiers;
7399	Name name;
7400	Name tmpName;
7401	NodeList<Name> names=emptyNodeList();
7402	JavaToken begin;
7403	ModuleDirective directive;
7404	JavaToken transitiveExceptionalToken;
7405	if (jj_2_58(2147483647)) {
7406	jj_consume_token(REQUIRES);
7407	begin=token();
7408	jj_consume_token(TRANSITIVE);
7409	transitiveExceptionalToken=token(); setTokenKind(IDENTIFIER);
7410	jj_consume_token(SEMICOLON);
7411	directive=new ModuleRequiresDirective(range(begin, token()), new NodeList<Modifier>(), new Name(range(transitiveExceptionalToken, transitiveExceptionalToken), null, transitiveExceptionalToken.getText()));
7412	} else {
7413	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7414	case REQUIRES:{
7415	jj_consume_token(REQUIRES);
7416	begin=token();
7417	modifiers = Modifiers();
7418	name = Name();
7419	jj_consume_token(SEMICOLON);
7420	directive=new ModuleRequiresDirective(range(begin, token()), modifiers.modifiers, name);
7421	break;
7422	}
7423	case EXPORTS:{
7424	jj_consume_token(EXPORTS);
7425	begin=token();
7426	name = Name();
7427	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7428	case TO:{
7429	jj_consume_token(TO);
7430	tmpName = Name();
7431	names.add(tmpName);
7432	label_55:
7433	while (true) {
7434	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7435	case COMMA:{
7436	break;
7437	}
7438	default:
7439	jj_la1[160] = jj_gen;
7440	break label_55;
7441	}
7442	jj_consume_token(COMMA);
7443	tmpName = Name();
7444	names.add(tmpName);
7445	}
7446	break;
7447	}
7448	default:
7449	jj_la1[161] = jj_gen;
7450	;
7451	}
7452	jj_consume_token(SEMICOLON);
7453	directive=new ModuleExportsDirective(range(begin, token()), name, names);
7454	break;
7455	}
7456	case OPENS:{
7457	jj_consume_token(OPENS);
7458	begin=token();
7459	name = Name();
7460	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7461	case TO:{
7462	jj_consume_token(TO);
7463	tmpName = Name();
7464	names.add(tmpName);
7465	label_56:
7466	while (true) {
7467	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7468	case COMMA:{
7469	break;
7470	}
7471	default:
7472	jj_la1[162] = jj_gen;
7473	break label_56;
7474	}
7475	jj_consume_token(COMMA);
7476	tmpName = Name();
7477	names.add(tmpName);
7478	}
7479	break;
7480	}
7481	default:
7482	jj_la1[163] = jj_gen;
7483	;
7484	}
7485	jj_consume_token(SEMICOLON);
7486	directive=new ModuleOpensDirective(range(begin, token()), name, names);
7487	break;
7488	}
7489	case USES:{
7490	jj_consume_token(USES);
7491	begin=token();
7492	name = Name();
7493	jj_consume_token(SEMICOLON);
7494	directive=new ModuleUsesDirective(range(begin, token()), name);
7495	break;
7496	}
7497	case PROVIDES:{
7498	jj_consume_token(PROVIDES);
7499	begin=token();
7500	name = Name();
7501	jj_consume_token(WITH);
7502	tmpName = Name();
7503	names.add(tmpName);
7504	label_57:
7505	while (true) {
7506	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7507	case COMMA:{
7508	break;
7509	}
7510	default:
7511	jj_la1[164] = jj_gen;
7512	break label_57;
7513	}
7514	jj_consume_token(COMMA);
7515	tmpName = Name();
7516	names.add(tmpName);
7517	}
7518	jj_consume_token(SEMICOLON);
7519	directive=new ModuleProvidesDirective(range(begin, token()), name, names);
7520	break;
7521	}
7522	default:
7523	jj_la1[165] = jj_gen;
7524	jj_consume_token(-1);
7525	throw new ParseException();
7526	}
7527	}
7528	{if ("" != null) return directive;}
7529	throw new IllegalStateException ("Missing return statement in function");
7530	}
7531
7532	/**
7533	* https://docs.oracle.com/javase/specs/jls/se15/html/jls-7.html#jls-7.7
7534	* <pre>{@code
7535	* ModuleDeclaration:
7536	* {Annotation} [open] module Identifier {. Identifier} { {ModuleDirective} }
7537	* }<pre>
7538	*/
7539	final public ModuleDeclaration ModuleDeclaration(ModifierHolder modifier) throws ParseException {NodeList<ModuleDirective> directives = new NodeList<ModuleDirective>();
7540	boolean open=false;
7541	ModuleDirective directive;
7542	Name name;
7543	JavaToken begin = modifier.begin;
7544	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7545	case OPEN:{
7546	jj_consume_token(OPEN);
7547	open = true; begin = orIfInvalid(begin, token());
7548	break;
7549	}
7550	default:
7551	jj_la1[166] = jj_gen;
7552	;
7553	}
7554	jj_consume_token(MODULE);
7555	begin = orIfInvalid(begin, token());
7556	name = Name();
7557	jj_consume_token(LBRACE);
7558	label_58:
7559	while (true) {
7560	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7561	case REQUIRES:
7562	case OPENS:
7563	case USES:
7564	case EXPORTS:
7565	case PROVIDES:{
7566	break;
7567	}
7568	default:
7569	jj_la1[167] = jj_gen;
7570	break label_58;
7571	}
7572	directive = ModuleDirective();
7573	directives = add(directives, directive);
7574	}
7575	jj_consume_token(RBRACE);
7576	{if ("" != null) return new ModuleDeclaration(range(begin, token()), modifier.annotations, name, open, directives);}
7577	throw new IllegalStateException ("Missing return statement in function");
7578	}
7579
7580	/* Rules for matching partial inputs.
7581	These rules are needed to properly terminate them -
7582	if we simply use the usual rules, they will ignore everything in the provider
7583	after they matched their desired input, which will lead to unexpected behaviour
7584	*/
7585	final public
7586
7587	BlockStmt BlockParseStart() throws ParseException {BlockStmt ret;
7588	ret = Block();
7589	jj_consume_token(0);
7590	{if ("" != null) return ret;}
7591	throw new IllegalStateException ("Missing return statement in function");
7592	}
7593
7594	final public Statement BlockStatementParseStart() throws ParseException {Statement ret;
7595	if (jj_2_59(3)) {
7596	ret = BlockStatement();
7597	} else {
7598	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7599	case BOOLEAN:
7600	case BYTE:
7601	case CHAR:
7602	case DOUBLE:
7603	case ENUM:
7604	case FALSE:
7605	case FLOAT:
7606	case INT:
7607	case LONG:
7608	case NEW:
7609	case NULL:
7610	case SHORT:
7611	case STRICTFP:
7612	case SUPER:
7613	case THIS:
7614	case TRUE:
7615	case VOID:
7616	case YIELD:
7617	case REQUIRES:
7618	case TO:
7619	case WITH:
7620	case OPEN:
7621	case OPENS:
7622	case USES:
7623	case MODULE:
7624	case EXPORTS:
7625	case PROVIDES:
7626	case TRANSITIVE:
7627	case LONG_LITERAL:
7628	case INTEGER_LITERAL:
7629	case FLOATING_POINT_LITERAL:
7630	case CHARACTER_LITERAL:
7631	case STRING_LITERAL:
7632	case TEXT_BLOCK_LITERAL:
7633	case IDENTIFIER:
7634	case LPAREN:
7635	case AT:
7636	case LT:{
7637	ret = ExplicitConstructorInvocation();
7638	break;
7639	}
7640	default:
7641	jj_la1[168] = jj_gen;
7642	jj_consume_token(-1);
7643	throw new ParseException();
7644	}
7645	}
7646	jj_consume_token(0);
7647	{if ("" != null) return ret;}
7648	throw new IllegalStateException ("Missing return statement in function");
7649	}
7650
7651	final public ImportDeclaration ImportDeclarationParseStart() throws ParseException {ImportDeclaration ret;
7652	ret = ImportDeclaration();
7653	jj_consume_token(0);
7654	{if ("" != null) return ret;}
7655	throw new IllegalStateException ("Missing return statement in function");
7656	}
7657
7658	final public Expression ExpressionParseStart() throws ParseException {Expression ret;
7659	ret = Expression();
7660	jj_consume_token(0);
7661	{if ("" != null) return ret;}
7662	throw new IllegalStateException ("Missing return statement in function");
7663	}
7664
7665	final public AnnotationExpr AnnotationParseStart() throws ParseException {AnnotationExpr ret;
7666	ret = Annotation();
7667	jj_consume_token(0);
7668	{if ("" != null) return ret;}
7669	throw new IllegalStateException ("Missing return statement in function");
7670	}
7671
7672	final public BodyDeclaration<?> AnnotationBodyDeclarationParseStart() throws ParseException {BodyDeclaration<?> ret;
7673	ret = AnnotationBodyDeclaration();
7674	jj_consume_token(0);
7675	{if ("" != null) return ret;}
7676	throw new IllegalStateException ("Missing return statement in function");
7677	}
7678
7679	final public BodyDeclaration<?> ClassOrInterfaceBodyDeclarationParseStart() throws ParseException {BodyDeclaration<?> ret;
7680	ret = ClassOrInterfaceBodyDeclaration();
7681	jj_consume_token(0);
7682	{if ("" != null) return ret;}
7683	throw new IllegalStateException ("Missing return statement in function");
7684	}
7685
7686	final public ClassOrInterfaceType ClassOrInterfaceTypeParseStart() throws ParseException {ClassOrInterfaceType ret;
7687	ret = AnnotatedClassOrInterfaceType();
7688	jj_consume_token(0);
7689	{if ("" != null) return ret;}
7690	throw new IllegalStateException ("Missing return statement in function");
7691	}
7692
7693	final public Type ResultTypeParseStart() throws ParseException {NodeList<AnnotationExpr> annotations; Type ret;
7694	annotations = Annotations();
7695	ret = ResultType(annotations);
7696	jj_consume_token(0);
7697	{if ("" != null) return ret;}
7698	throw new IllegalStateException ("Missing return statement in function");
7699	}
7700
7701	final public VariableDeclarationExpr VariableDeclarationExpressionParseStart() throws ParseException {VariableDeclarationExpr ret;
7702	ret = VariableDeclarationExpression();
7703	jj_consume_token(0);
7704	{if ("" != null) return ret;}
7705	throw new IllegalStateException ("Missing return statement in function");
7706	}
7707
7708	final public ExplicitConstructorInvocationStmt ExplicitConstructorInvocationParseStart() throws ParseException {ExplicitConstructorInvocationStmt ret;
7709	ret = ExplicitConstructorInvocation();
7710	jj_consume_token(0);
7711	{if ("" != null) return ret;}
7712	throw new IllegalStateException ("Missing return statement in function");
7713	}
7714
7715	final public Name NameParseStart() throws ParseException {Name ret;
7716	ret = Name();
7717	jj_consume_token(0);
7718	{if ("" != null) return ret;}
7719	throw new IllegalStateException ("Missing return statement in function");
7720	}
7721
7722	final public SimpleName SimpleNameParseStart() throws ParseException {SimpleName ret;
7723	ret = SimpleName();
7724	jj_consume_token(0);
7725	{if ("" != null) return ret;}
7726	throw new IllegalStateException ("Missing return statement in function");
7727	}
7728
7729	final public Parameter ParameterParseStart() throws ParseException {Parameter ret;
7730	ret = Parameter();
7731	jj_consume_token(0);
7732	{if ("" != null) return ret;}
7733	throw new IllegalStateException ("Missing return statement in function");
7734	}
7735
7736	final public PackageDeclaration PackageDeclarationParseStart() throws ParseException {PackageDeclaration ret;
7737	ret = PackageDeclaration();
7738	jj_consume_token(0);
7739	{if ("" != null) return ret;}
7740	throw new IllegalStateException ("Missing return statement in function");
7741	}
7742
7743	final public TypeDeclaration<?> TypeDeclarationParseStart() throws ParseException {TypeDeclaration<?> ret;
7744	ModifierHolder modifier;
7745	modifier = Modifiers();
7746	switch (jj_ntk == -1 ? jj_ntk_f() : jj_ntk) {
7747	case CLASS:
7748	case INTERFACE:{
7749	ret = ClassOrInterfaceDeclaration(modifier);
7750	break;
7751	}
7752	case ENUM:{
7753	ret = EnumDeclaration(modifier);
7754	break;
7755	}
7756	case AT:{
7757	ret = AnnotationTypeDeclaration(modifier);
7758	break;
7759	}
7760	default:
7761	jj_la1[169] = jj_gen;
7762	jj_consume_token(-1);
7763	throw new ParseException();
7764	}
7765	jj_consume_token(0);
7766	{if ("" != null) return ret;}
7767	throw new IllegalStateException ("Missing return statement in function");
7768	}
7769
7770	final public ModuleDeclaration ModuleDeclarationParseStart() throws ParseException {ModuleDeclaration ret;
7771	ModifierHolder modifiers;
7772	modifiers = Modifiers();
7773	ret = ModuleDeclaration(modifiers);
7774	jj_consume_token(0);
7775	{if ("" != null) return ret;}
7776	throw new IllegalStateException ("Missing return statement in function");
7777	}
7778
7779	final public ModuleDirective ModuleDirectiveParseStart() throws ParseException {ModuleDirective ret;
7780	ret = ModuleDirective();
7781	jj_consume_token(0);
7782	{if ("" != null) return ret;}
7783	throw new IllegalStateException ("Missing return statement in function");
7784	}
7785
7786	final public TypeParameter TypeParameterParseStart() throws ParseException {TypeParameter ret;
7787	NodeList<AnnotationExpr> annotations;
7788	annotations = Annotations();
7789	ret = TypeParameter(annotations);
7790	jj_consume_token(0);
7791	{if ("" != null) return ret;}
7792	throw new IllegalStateException ("Missing return statement in function");
7793	}
7794
7795	final public MethodDeclaration MethodDeclarationParseStart() throws ParseException {MethodDeclaration ret;
7796	ModifierHolder modifier;
7797	modifier = Modifiers();
7798	ret = MethodDeclaration(modifier);
7799	jj_consume_token(0);
7800	{if ("" != null) return ret;}
7801	throw new IllegalStateException ("Missing return statement in function");
7802	}
7803
7804	private boolean jj_2_1(int xla)
7805	{
7806	jj_la = xla;
7807	jj_scanpos = token;
7808	jj_lastpos = token;
7809	try { return (!jj_3_1()); }
7810	catch(LookaheadSuccess ls) { return true; }
7811	finally { jj_save(0, xla); }
7812	}
7813
7814	private boolean jj_2_2(int xla)
7815	{
7816	jj_la = xla;
7817	jj_scanpos = token;
7818	jj_lastpos = token;
7819	try { return (!jj_3_2()); }
7820	catch(LookaheadSuccess ls) { return true; }
7821	finally { jj_save(1, xla); }
7822	}
7823
7824	private boolean jj_2_3(int xla)
7825	{
7826	jj_la = xla;
7827	jj_scanpos = token;
7828	jj_lastpos = token;
7829	try { return (!jj_3_3()); }
7830	catch(LookaheadSuccess ls) { return true; }
7831	finally { jj_save(2, xla); }
7832	}
7833
7834	private boolean jj_2_4(int xla)
7835	{
7836	jj_la = xla;
7837	jj_scanpos = token;
7838	jj_lastpos = token;
7839	try { return (!jj_3_4()); }
7840	catch(LookaheadSuccess ls) { return true; }
7841	finally { jj_save(3, xla); }
7842	}
7843
7844	private boolean jj_2_5(int xla)
7845	{
7846	jj_la = xla;
7847	jj_scanpos = token;
7848	jj_lastpos = token;
7849	try { return (!jj_3_5()); }
7850	catch(LookaheadSuccess ls) { return true; }
7851	finally { jj_save(4, xla); }
7852	}
7853
7854	private boolean jj_2_6(int xla)
7855	{
7856	jj_la = xla;
7857	jj_scanpos = token;
7858	jj_lastpos = token;
7859	try { return (!jj_3_6()); }
7860	catch(LookaheadSuccess ls) { return true; }
7861	finally { jj_save(5, xla); }
7862	}
7863
7864	private boolean jj_2_7(int xla)
7865	{
7866	jj_la = xla;
7867	jj_scanpos = token;
7868	jj_lastpos = token;
7869	try { return (!jj_3_7()); }
7870	catch(LookaheadSuccess ls) { return true; }
7871	finally { jj_save(6, xla); }
7872	}
7873
7874	private boolean jj_2_8(int xla)
7875	{
7876	jj_la = xla;
7877	jj_scanpos = token;
7878	jj_lastpos = token;
7879	try { return (!jj_3_8()); }
7880	catch(LookaheadSuccess ls) { return true; }
7881	finally { jj_save(7, xla); }
7882	}
7883
7884	private boolean jj_2_9(int xla)
7885	{
7886	jj_la = xla;
7887	jj_scanpos = token;
7888	jj_lastpos = token;
7889	try { return (!jj_3_9()); }
7890	catch(LookaheadSuccess ls) { return true; }
7891	finally { jj_save(8, xla); }
7892	}
7893
7894	private boolean jj_2_10(int xla)
7895	{
7896	jj_la = xla;
7897	jj_scanpos = token;
7898	jj_lastpos = token;
7899	try { return (!jj_3_10()); }
7900	catch(LookaheadSuccess ls) { return true; }
7901	finally { jj_save(9, xla); }
7902	}
7903
7904	private boolean jj_2_11(int xla)
7905	{
7906	jj_la = xla;
7907	jj_scanpos = token;
7908	jj_lastpos = token;
7909	try { return (!jj_3_11()); }
7910	catch(LookaheadSuccess ls) { return true; }
7911	finally { jj_save(10, xla); }
7912	}
7913
7914	private boolean jj_2_12(int xla)
7915	{
7916	jj_la = xla;
7917	jj_scanpos = token;
7918	jj_lastpos = token;
7919	try { return (!jj_3_12()); }
7920	catch(LookaheadSuccess ls) { return true; }
7921	finally { jj_save(11, xla); }
7922	}
7923
7924	private boolean jj_2_13(int xla)
7925	{
7926	jj_la = xla;
7927	jj_scanpos = token;
7928	jj_lastpos = token;
7929	try { return (!jj_3_13()); }
7930	catch(LookaheadSuccess ls) { return true; }
7931	finally { jj_save(12, xla); }
7932	}
7933
7934	private boolean jj_2_14(int xla)
7935	{
7936	jj_la = xla;
7937	jj_scanpos = token;
7938	jj_lastpos = token;
7939	try { return (!jj_3_14()); }
7940	catch(LookaheadSuccess ls) { return true; }
7941	finally { jj_save(13, xla); }
7942	}
7943
7944	private boolean jj_2_15(int xla)
7945	{
7946	jj_la = xla;
7947	jj_scanpos = token;
7948	jj_lastpos = token;
7949	try { return (!jj_3_15()); }
7950	catch(LookaheadSuccess ls) { return true; }
7951	finally { jj_save(14, xla); }
7952	}
7953
7954	private boolean jj_2_16(int xla)
7955	{
7956	jj_la = xla;
7957	jj_scanpos = token;
7958	jj_lastpos = token;
7959	try { return (!jj_3_16()); }
7960	catch(LookaheadSuccess ls) { return true; }
7961	finally { jj_save(15, xla); }
7962	}
7963
7964	private boolean jj_2_17(int xla)
7965	{
7966	jj_la = xla;
7967	jj_scanpos = token;
7968	jj_lastpos = token;
7969	try { return (!jj_3_17()); }
7970	catch(LookaheadSuccess ls) { return true; }
7971	finally { jj_save(16, xla); }
7972	}
7973
7974	private boolean jj_2_18(int xla)
7975	{
7976	jj_la = xla;
7977	jj_scanpos = token;
7978	jj_lastpos = token;
7979	try { return (!jj_3_18()); }
7980	catch(LookaheadSuccess ls) { return true; }
7981	finally { jj_save(17, xla); }
7982	}
7983
7984	private boolean jj_2_19(int xla)
7985	{
7986	jj_la = xla;
7987	jj_scanpos = token;
7988	jj_lastpos = token;
7989	try { return (!jj_3_19()); }
7990	catch(LookaheadSuccess ls) { return true; }
7991	finally { jj_save(18, xla); }
7992	}
7993
7994	private boolean jj_2_20(int xla)
7995	{
7996	jj_la = xla;
7997	jj_scanpos = token;
7998	jj_lastpos = token;
7999	try { return (!jj_3_20()); }
8000	catch(LookaheadSuccess ls) { return true; }
8001	finally { jj_save(19, xla); }
8002	}
8003
8004	private boolean jj_2_21(int xla)
8005	{
8006	jj_la = xla;
8007	jj_scanpos = token;
8008	jj_lastpos = token;
8009	try { return (!jj_3_21()); }
8010	catch(LookaheadSuccess ls) { return true; }
8011	finally { jj_save(20, xla); }
8012	}
8013
8014	private boolean jj_2_22(int xla)
8015	{
8016	jj_la = xla;
8017	jj_scanpos = token;
8018	jj_lastpos = token;
8019	try { return (!jj_3_22()); }
8020	catch(LookaheadSuccess ls) { return true; }
8021	finally { jj_save(21, xla); }
8022	}
8023
8024	private boolean jj_2_23(int xla)
8025	{
8026	jj_la = xla;
8027	jj_scanpos = token;
8028	jj_lastpos = token;
8029	try { return (!jj_3_23()); }
8030	catch(LookaheadSuccess ls) { return true; }
8031	finally { jj_save(22, xla); }
8032	}
8033
8034	private boolean jj_2_24(int xla)
8035	{
8036	jj_la = xla;
8037	jj_scanpos = token;
8038	jj_lastpos = token;
8039	try { return (!jj_3_24()); }
8040	catch(LookaheadSuccess ls) { return true; }
8041	finally { jj_save(23, xla); }
8042	}
8043
8044	private boolean jj_2_25(int xla)
8045	{
8046	jj_la = xla;
8047	jj_scanpos = token;
8048	jj_lastpos = token;
8049	try { return (!jj_3_25()); }
8050	catch(LookaheadSuccess ls) { return true; }
8051	finally { jj_save(24, xla); }
8052	}
8053
8054	private boolean jj_2_26(int xla)
8055	{
8056	jj_la = xla;
8057	jj_scanpos = token;
8058	jj_lastpos = token;
8059	try { return (!jj_3_26()); }
8060	catch(LookaheadSuccess ls) { return true; }
8061	finally { jj_save(25, xla); }
8062	}
8063
8064	private boolean jj_2_27(int xla)
8065	{
8066	jj_la = xla;
8067	jj_scanpos = token;
8068	jj_lastpos = token;
8069	try { return (!jj_3_27()); }
8070	catch(LookaheadSuccess ls) { return true; }
8071	finally { jj_save(26, xla); }
8072	}
8073
8074	private boolean jj_2_28(int xla)
8075	{
8076	jj_la = xla;
8077	jj_scanpos = token;
8078	jj_lastpos = token;
8079	try { return (!jj_3_28()); }
8080	catch(LookaheadSuccess ls) { return true; }
8081	finally { jj_save(27, xla); }
8082	}
8083
8084	private boolean jj_2_29(int xla)
8085	{
8086	jj_la = xla;
8087	jj_scanpos = token;
8088	jj_lastpos = token;
8089	try { return (!jj_3_29()); }
8090	catch(LookaheadSuccess ls) { return true; }
8091	finally { jj_save(28, xla); }
8092	}
8093
8094	private boolean jj_2_30(int xla)
8095	{
8096	jj_la = xla;
8097	jj_scanpos = token;
8098	jj_lastpos = token;
8099	try { return (!jj_3_30()); }
8100	catch(LookaheadSuccess ls) { return true; }
8101	finally { jj_save(29, xla); }
8102	}
8103
8104	private boolean jj_2_31(int xla)
8105	{
8106	jj_la = xla;
8107	jj_scanpos = token;
8108	jj_lastpos = token;
8109	try { return (!jj_3_31()); }
8110	catch(LookaheadSuccess ls) { return true; }
8111	finally { jj_save(30, xla); }
8112	}
8113
8114	private boolean jj_2_32(int xla)
8115	{
8116	jj_la = xla;
8117	jj_scanpos = token;
8118	jj_lastpos = token;
8119	try { return (!jj_3_32()); }
8120	catch(LookaheadSuccess ls) { return true; }
8121	finally { jj_save(31, xla); }
8122	}
8123
8124	private boolean jj_2_33(int xla)
8125	{
8126	jj_la = xla;
8127	jj_scanpos = token;
8128	jj_lastpos = token;
8129	try { return (!jj_3_33()); }
8130	catch(LookaheadSuccess ls) { return true; }
8131	finally { jj_save(32, xla); }
8132	}
8133
8134	private boolean jj_2_34(int xla)
8135	{
8136	jj_la = xla;
8137	jj_scanpos = token;
8138	jj_lastpos = token;
8139	try { return (!jj_3_34()); }
8140	catch(LookaheadSuccess ls) { return true; }
8141	finally { jj_save(33, xla); }
8142	}
8143
8144	private boolean jj_2_35(int xla)
8145	{
8146	jj_la = xla;
8147	jj_scanpos = token;
8148	jj_lastpos = token;
8149	try { return (!jj_3_35()); }
8150	catch(LookaheadSuccess ls) { return true; }
8151	finally { jj_save(34, xla); }
8152	}
8153
8154	private boolean jj_2_36(int xla)
8155	{
8156	jj_la = xla;
8157	jj_scanpos = token;
8158	jj_lastpos = token;
8159	try { return (!jj_3_36()); }
8160	catch(LookaheadSuccess ls) { return true; }
8161	finally { jj_save(35, xla); }
8162	}
8163
8164	private boolean jj_2_37(int xla)
8165	{
8166	jj_la = xla;
8167	jj_scanpos = token;
8168	jj_lastpos = token;
8169	try { return (!jj_3_37()); }
8170	catch(LookaheadSuccess ls) { return true; }
8171	finally { jj_save(36, xla); }
8172	}
8173
8174	private boolean jj_2_38(int xla)
8175	{
8176	jj_la = xla;
8177	jj_scanpos = token;
8178	jj_lastpos = token;
8179	try { return (!jj_3_38()); }
8180	catch(LookaheadSuccess ls) { return true; }
8181	finally { jj_save(37, xla); }
8182	}
8183
8184	private boolean jj_2_39(int xla)
8185	{
8186	jj_la = xla;
8187	jj_scanpos = token;
8188	jj_lastpos = token;
8189	try { return (!jj_3_39()); }
8190	catch(LookaheadSuccess ls) { return true; }
8191	finally { jj_save(38, xla); }
8192	}
8193
8194	private boolean jj_2_40(int xla)
8195	{
8196	jj_la = xla;
8197	jj_scanpos = token;
8198	jj_lastpos = token;
8199	try { return (!jj_3_40()); }
8200	catch(LookaheadSuccess ls) { return true; }
8201	finally { jj_save(39, xla); }
8202	}
8203
8204	private boolean jj_2_41(int xla)
8205	{
8206	jj_la = xla;
8207	jj_scanpos = token;
8208	jj_lastpos = token;
8209	try { return (!jj_3_41()); }
8210	catch(LookaheadSuccess ls) { return true; }
8211	finally { jj_save(40, xla); }
8212	}
8213
8214	private boolean jj_2_42(int xla)
8215	{
8216	jj_la = xla;
8217	jj_scanpos = token;
8218	jj_lastpos = token;
8219	try { return (!jj_3_42()); }
8220	catch(LookaheadSuccess ls) { return true; }
8221	finally { jj_save(41, xla); }
8222	}
8223
8224	private boolean jj_2_43(int xla)
8225	{
8226	jj_la = xla;
8227	jj_scanpos = token;
8228	jj_lastpos = token;
8229	try { return (!jj_3_43()); }
8230	catch(LookaheadSuccess ls) { return true; }
8231	finally { jj_save(42, xla); }
8232	}
8233
8234	private boolean jj_2_44(int xla)
8235	{
8236	jj_la = xla;
8237	jj_scanpos = token;
8238	jj_lastpos = token;
8239	try { return (!jj_3_44()); }
8240	catch(LookaheadSuccess ls) { return true; }
8241	finally { jj_save(43, xla); }
8242	}
8243
8244	private boolean jj_2_45(int xla)
8245	{
8246	jj_la = xla;
8247	jj_scanpos = token;
8248	jj_lastpos = token;
8249	try { return (!jj_3_45()); }
8250	catch(LookaheadSuccess ls) { return true; }
8251	finally { jj_save(44, xla); }
8252	}
8253
8254	private boolean jj_2_46(int xla)
8255	{
8256	jj_la = xla;
8257	jj_scanpos = token;
8258	jj_lastpos = token;
8259	try { return (!jj_3_46()); }
8260	catch(LookaheadSuccess ls) { return true; }
8261	finally { jj_save(45, xla); }
8262	}
8263
8264	private boolean jj_2_47(int xla)
8265	{
8266	jj_la = xla;
8267	jj_scanpos = token;
8268	jj_lastpos = token;
8269	try { return (!jj_3_47()); }
8270	catch(LookaheadSuccess ls) { return true; }
8271	finally { jj_save(46, xla); }
8272	}
8273
8274	private boolean jj_2_48(int xla)
8275	{
8276	jj_la = xla;
8277	jj_scanpos = token;
8278	jj_lastpos = token;
8279	try { return (!jj_3_48()); }
8280	catch(LookaheadSuccess ls) { return true; }
8281	finally { jj_save(47, xla); }
8282	}
8283
8284	private boolean jj_2_49(int xla)
8285	{
8286	jj_la = xla;
8287	jj_scanpos = token;
8288	jj_lastpos = token;
8289	try { return (!jj_3_49()); }
8290	catch(LookaheadSuccess ls) { return true; }
8291	finally { jj_save(48, xla); }
8292	}
8293
8294	private boolean jj_2_50(int xla)
8295	{
8296	jj_la = xla;
8297	jj_scanpos = token;
8298	jj_lastpos = token;
8299	try { return (!jj_3_50()); }
8300	catch(LookaheadSuccess ls) { return true; }
8301	finally { jj_save(49, xla); }
8302	}
8303
8304	private boolean jj_2_51(int xla)
8305	{
8306	jj_la = xla;
8307	jj_scanpos = token;
8308	jj_lastpos = token;
8309	try { return (!jj_3_51()); }
8310	catch(LookaheadSuccess ls) { return true; }
8311	finally { jj_save(50, xla); }
8312	}
8313
8314	private boolean jj_2_52(int xla)
8315	{
8316	jj_la = xla;
8317	jj_scanpos = token;
8318	jj_lastpos = token;
8319	try { return (!jj_3_52()); }
8320	catch(LookaheadSuccess ls) { return true; }
8321	finally { jj_save(51, xla); }
8322	}
8323
8324	private boolean jj_2_53(int xla)
8325	{
8326	jj_la = xla;
8327	jj_scanpos = token;
8328	jj_lastpos = token;
8329	try { return (!jj_3_53()); }
8330	catch(LookaheadSuccess ls) { return true; }
8331	finally { jj_save(52, xla); }
8332	}
8333
8334	private boolean jj_2_54(int xla)
8335	{
8336	jj_la = xla;
8337	jj_scanpos = token;
8338	jj_lastpos = token;
8339	try { return (!jj_3_54()); }
8340	catch(LookaheadSuccess ls) { return true; }
8341	finally { jj_save(53, xla); }
8342	}
8343
8344	private boolean jj_2_55(int xla)
8345	{
8346	jj_la = xla;
8347	jj_scanpos = token;
8348	jj_lastpos = token;
8349	try { return (!jj_3_55()); }
8350	catch(LookaheadSuccess ls) { return true; }
8351	finally { jj_save(54, xla); }
8352	}
8353
8354	private boolean jj_2_56(int xla)
8355	{
8356	jj_la = xla;
8357	jj_scanpos = token;
8358	jj_lastpos = token;
8359	try { return (!jj_3_56()); }
8360	catch(LookaheadSuccess ls) { return true; }
8361	finally { jj_save(55, xla); }
8362	}
8363
8364	private boolean jj_2_57(int xla)
8365	{
8366	jj_la = xla;
8367	jj_scanpos = token;
8368	jj_lastpos = token;
8369	try { return (!jj_3_57()); }
8370	catch(LookaheadSuccess ls) { return true; }
8371	finally { jj_save(56, xla); }
8372	}
8373
8374	private boolean jj_2_58(int xla)
8375	{
8376	jj_la = xla;
8377	jj_scanpos = token;
8378	jj_lastpos = token;
8379	try { return (!jj_3_58()); }
8380	catch(LookaheadSuccess ls) { return true; }
8381	finally { jj_save(57, xla); }
8382	}
8383
8384	private boolean jj_2_59(int xla)
8385	{
8386	jj_la = xla;
8387	jj_scanpos = token;
8388	jj_lastpos = token;
8389	try { return (!jj_3_59()); }
8390	catch(LookaheadSuccess ls) { return true; }
8391	finally { jj_save(58, xla); }
8392	}
8393
8394	private boolean jj_3R_293()
8395	{
8396	if (jj_scan_token(SEMICOLON)) return true;
8397	return false;
8398	}
8399
8400	private boolean jj_3R_385()
8401	{
8402	if (jj_3R_393()) return true;
8403	Token xsp;
8404	xsp = jj_scanpos;
8405	if (jj_3R_397()) jj_scanpos = xsp;
8406	return false;
8407	}
8408
8409	private boolean jj_3R_363()
8410	{
8411	if (jj_scan_token(AT)) return true;
8412	if (jj_scan_token(INTERFACE)) return true;
8413	if (jj_3R_91()) return true;
8414	if (jj_3R_411()) return true;
8415	return false;
8416	}
8417
8418	private boolean jj_3R_397()
8419	{
8420	if (jj_scan_token(INSTANCEOF)) return true;
8421	if (jj_3R_254()) return true;
8422	return false;
8423	}
8424
8425	private boolean jj_3R_288()
8426	{
8427	if (jj_3R_104()) return true;
8428	Token xsp;
8429	while (true) {
8430	xsp = jj_scanpos;
8431	if (jj_3R_323()) { jj_scanpos = xsp; break; }
8432	}
8433	return false;
8434	}
8435
8436	private boolean jj_3R_336()
8437	{
8438	Token xsp;
8439	xsp = jj_scanpos;
8440	if (jj_3R_360()) {
8441	jj_scanpos = xsp;
8442	if (jj_3R_361()) return true;
8443	}
8444	return false;
8445	}
8446
8447	private boolean jj_3R_323()
8448	{
8449	if (jj_scan_token(COMMA)) return true;
8450	if (jj_3R_104()) return true;
8451	return false;
8452	}
8453
8454	private boolean jj_3R_360()
8455	{
8456	if (jj_3R_93()) return true;
8457	return false;
8458	}
8459
8460	private boolean jj_3R_361()
8461	{
8462	if (jj_3R_126()) return true;
8463	return false;
8464	}
8465
8466	private boolean jj_3R_393()
8467	{
8468	if (jj_3R_396()) return true;
8469	Token xsp;
8470	while (true) {
8471	xsp = jj_scanpos;
8472	if (jj_3R_401()) { jj_scanpos = xsp; break; }
8473	}
8474	return false;
8475	}
8476
8477	private boolean jj_3R_411()
8478	{
8479	if (jj_scan_token(LBRACE)) return true;
8480	Token xsp;
8481	while (true) {
8482	xsp = jj_scanpos;
8483	if (jj_3R_423()) { jj_scanpos = xsp; break; }
8484	}
8485	if (jj_scan_token(RBRACE)) return true;
8486	return false;
8487	}
8488
8489	private boolean jj_3R_401()
8490	{
8491	Token xsp;
8492	xsp = jj_scanpos;
8493	if (jj_3R_403()) {
8494	jj_scanpos = xsp;
8495	if (jj_3R_404()) {
8496	jj_scanpos = xsp;
8497	if (jj_3R_405()) {
8498	jj_scanpos = xsp;
8499	if (jj_3R_406()) return true;
8500	}
8501	}
8502	}
8503	if (jj_3R_396()) return true;
8504	return false;
8505	}
8506
8507	private boolean jj_3R_423()
8508	{
8509	Token xsp;
8510	xsp = jj_scanpos;
8511	if (jj_3R_439()) {
8512	jj_scanpos = xsp;
8513	if (jj_scan_token(102)) return true;
8514	}
8515	return false;
8516	}
8517
8518	private boolean jj_3R_439()
8519	{
8520	if (jj_3R_447()) return true;
8521	return false;
8522	}
8523
8524	private boolean jj_3R_294()
8525	{
8526	Token xsp;
8527	xsp = jj_scanpos;
8528	if (jj_3_45()) {
8529	jj_scanpos = xsp;
8530	if (jj_3R_327()) {
8531	jj_scanpos = xsp;
8532	if (jj_3R_328()) return true;
8533	}
8534	}
8535	if (jj_scan_token(SEMICOLON)) return true;
8536	return false;
8537	}
8538
8539	private boolean jj_3R_403()
8540	{
8541	if (jj_scan_token(LT)) return true;
8542	return false;
8543	}
8544
8545	private boolean jj_3R_103()
8546	{
8547	if (jj_3R_112()) return true;
8548	if (jj_3R_77()) return true;
8549	Token xsp;
8550	xsp = jj_scanpos;
8551	if (jj_3R_167()) jj_scanpos = xsp;
8552	if (jj_3R_104()) return true;
8553	return false;
8554	}
8555
8556	private boolean jj_3R_404()
8557	{
8558	if (jj_scan_token(GT)) return true;
8559	return false;
8560	}
8561
8562	private boolean jj_3_45()
8563	{
8564	if (jj_3R_114()) return true;
8565	return false;
8566	}
8567
8568	private boolean jj_3R_405()
8569	{
8570	if (jj_scan_token(LE)) return true;
8571	return false;
8572	}
8573
8574	private boolean jj_3R_327()
8575	{
8576	if (jj_3R_265()) return true;
8577	return false;
8578	}
8579
8580	private boolean jj_3R_406()
8581	{
8582	if (jj_scan_token(GE)) return true;
8583	return false;
8584	}
8585
8586	private boolean jj_3R_328()
8587	{
8588	if (jj_3R_213()) return true;
8589	Token xsp;
8590	xsp = jj_scanpos;
8591	if (jj_3R_354()) jj_scanpos = xsp;
8592	return false;
8593	}
8594
8595	private boolean jj_3R_167()
8596	{
8597	if (jj_3R_89()) return true;
8598	if (jj_scan_token(ELLIPSIS)) return true;
8599	return false;
8600	}
8601
8602	private boolean jj_3R_354()
8603	{
8604	Token xsp;
8605	xsp = jj_scanpos;
8606	if (jj_3R_371()) {
8607	jj_scanpos = xsp;
8608	if (jj_3R_372()) {
8609	jj_scanpos = xsp;
8610	if (jj_3R_373()) return true;
8611	}
8612	}
8613	return false;
8614	}
8615
8616	private boolean jj_3R_371()
8617	{
8618	if (jj_scan_token(INCR)) return true;
8619	return false;
8620	}
8621
8622	private boolean jj_3R_372()
8623	{
8624	if (jj_scan_token(DECR)) return true;
8625	return false;
8626	}
8627
8628	private boolean jj_3R_373()
8629	{
8630	if (jj_3R_92()) return true;
8631	if (jj_3R_93()) return true;
8632	return false;
8633	}
8634
8635	private boolean jj_3R_396()
8636	{
8637	if (jj_3R_400()) return true;
8638	Token xsp;
8639	while (true) {
8640	xsp = jj_scanpos;
8641	if (jj_3_25()) { jj_scanpos = xsp; break; }
8642	}
8643	return false;
8644	}
8645
8646	private boolean jj_3_25()
8647	{
8648	Token xsp;
8649	xsp = jj_scanpos;
8650	if (jj_3R_94()) {
8651	jj_scanpos = xsp;
8652	if (jj_3_26()) {
8653	jj_scanpos = xsp;
8654	if (jj_3_27()) return true;
8655	}
8656	}
8657	if (jj_3R_400()) return true;
8658	return false;
8659	}
8660
8661	private boolean jj_3_1()
8662	{
8663	if (jj_scan_token(SEMICOLON)) return true;
8664	return false;
8665	}
8666
8667	private boolean jj_3R_447()
8668	{
8669	if (jj_3R_112()) return true;
8670	Token xsp;
8671	xsp = jj_scanpos;
8672	if (jj_3R_450()) {
8673	jj_scanpos = xsp;
8674	if (jj_3R_451()) {
8675	jj_scanpos = xsp;
8676	if (jj_3R_452()) {
8677	jj_scanpos = xsp;
8678	if (jj_3R_453()) {
8679	jj_scanpos = xsp;
8680	if (jj_3R_454()) return true;
8681	}
8682	}
8683	}
8684	}
8685	return false;
8686	}
8687
8688	private boolean jj_3R_81()
8689	{
8690	if (jj_3R_89()) return true;
8691	if (jj_3R_77()) return true;
8692	if (jj_3R_129()) return true;
8693	return false;
8694	}
8695
8696	private boolean jj_3R_94()
8697	{
8698	if (jj_scan_token(LSHIFT)) return true;
8699	return false;
8700	}
8701
8702	private boolean jj_3_26()
8703	{
8704	if (jj_3R_95()) return true;
8705	return false;
8706	}
8707
8708	private boolean jj_3R_450()
8709	{
8710	if (jj_3R_455()) return true;
8711	return false;
8712	}
8713
8714	private boolean jj_3_27()
8715	{
8716	if (jj_3R_96()) return true;
8717	return false;
8718	}
8719
8720	private boolean jj_3R_451()
8721	{
8722	if (jj_3R_198()) return true;
8723	return false;
8724	}
8725
8726	private boolean jj_3_2()
8727	{
8728	if (jj_3R_59()) return true;
8729	return false;
8730	}
8731
8732	private boolean jj_3R_452()
8733	{
8734	if (jj_3R_362()) return true;
8735	return false;
8736	}
8737
8738	private boolean jj_3R_453()
8739	{
8740	if (jj_3R_363()) return true;
8741	return false;
8742	}
8743
8744	private boolean jj_3_56()
8745	{
8746	if (jj_3R_77()) return true;
8747	if (jj_3R_76()) return true;
8748	if (jj_scan_token(LPAREN)) return true;
8749	return false;
8750	}
8751
8752	private boolean jj_3R_454()
8753	{
8754	if (jj_3R_365()) return true;
8755	return false;
8756	}
8757
8758	private boolean jj_3_57()
8759	{
8760	if (jj_scan_token(ENUM)) return true;
8761	return false;
8762	}
8763
8764	private boolean jj_3R_295()
8765	{
8766	if (jj_scan_token(SWITCH)) return true;
8767	if (jj_scan_token(LPAREN)) return true;
8768	if (jj_3R_93()) return true;
8769	if (jj_scan_token(RPAREN)) return true;
8770	if (jj_scan_token(LBRACE)) return true;
8771	Token xsp;
8772	while (true) {
8773	xsp = jj_scanpos;
8774	if (jj_3R_429()) { jj_scanpos = xsp; break; }
8775	}
8776	if (jj_scan_token(RBRACE)) return true;
8777	return false;
8778	}
8779
8780	private boolean jj_3R_400()
8781	{
8782	if (jj_3R_402()) return true;
8783	Token xsp;
8784	while (true) {
8785	xsp = jj_scanpos;
8786	if (jj_3R_407()) { jj_scanpos = xsp; break; }
8787	}
8788	return false;
8789	}
8790
8791	private boolean jj_3R_129()
8792	{
8793	Token xsp;
8794	xsp = jj_scanpos;
8795	if (jj_3R_185()) jj_scanpos = xsp;
8796	if (jj_scan_token(THIS)) return true;
8797	return false;
8798	}
8799
8800	private boolean jj_3R_185()
8801	{
8802	if (jj_3R_82()) return true;
8803	if (jj_scan_token(DOT)) return true;
8804	return false;
8805	}
8806
8807	private boolean jj_3R_407()
8808	{
8809	Token xsp;
8810	xsp = jj_scanpos;
8811	if (jj_3R_420()) {
8812	jj_scanpos = xsp;
8813	if (jj_3R_421()) return true;
8814	}
8815	if (jj_3R_402()) return true;
8816	return false;
8817	}
8818
8819	private boolean jj_3R_429()
8820	{
8821	if (jj_3R_359()) return true;
8822	return false;
8823	}
8824
8825	private boolean jj_3R_420()
8826	{
8827	if (jj_scan_token(PLUS)) return true;
8828	return false;
8829	}
8830
8831	private boolean jj_3_12()
8832	{
8833	if (jj_3R_82()) return true;
8834	return false;
8835	}
8836
8837	private boolean jj_3R_421()
8838	{
8839	if (jj_scan_token(MINUS)) return true;
8840	return false;
8841	}
8842
8843	private boolean jj_3R_59()
8844	{
8845	if (jj_3R_89()) return true;
8846	if (jj_scan_token(PACKAGE)) return true;
8847	if (jj_3R_82()) return true;
8848	if (jj_scan_token(SEMICOLON)) return true;
8849	return false;
8850	}
8851
8852	private boolean jj_3R_455()
8853	{
8854	if (jj_3R_77()) return true;
8855	if (jj_3R_91()) return true;
8856	if (jj_scan_token(LPAREN)) return true;
8857	if (jj_scan_token(RPAREN)) return true;
8858	Token xsp;
8859	xsp = jj_scanpos;
8860	if (jj_3R_457()) jj_scanpos = xsp;
8861	if (jj_scan_token(SEMICOLON)) return true;
8862	return false;
8863	}
8864
8865	private boolean jj_3R_457()
8866	{
8867	if (jj_3R_458()) return true;
8868	return false;
8869	}
8870
8871	private boolean jj_3R_402()
8872	{
8873	if (jj_3R_173()) return true;
8874	Token xsp;
8875	while (true) {
8876	xsp = jj_scanpos;
8877	if (jj_3R_419()) { jj_scanpos = xsp; break; }
8878	}
8879	return false;
8880	}
8881
8882	private boolean jj_3R_419()
8883	{
8884	Token xsp;
8885	xsp = jj_scanpos;
8886	if (jj_3R_433()) {
8887	jj_scanpos = xsp;
8888	if (jj_3R_434()) {
8889	jj_scanpos = xsp;
8890	if (jj_3R_435()) return true;
8891	}
8892	}
8893	if (jj_3R_173()) return true;
8894	return false;
8895	}
8896
8897	private boolean jj_3R_433()
8898	{
8899	if (jj_scan_token(STAR)) return true;
8900	return false;
8901	}
8902
8903	private boolean jj_3R_364()
8904	{
8905	Token xsp;
8906	xsp = jj_scanpos;
8907	if (jj_3R_380()) jj_scanpos = xsp;
8908	if (jj_3R_91()) return true;
8909	if (jj_3R_412()) return true;
8910	xsp = jj_scanpos;
8911	if (jj_3R_413()) jj_scanpos = xsp;
8912	if (jj_scan_token(LBRACE)) return true;
8913	xsp = jj_scanpos;
8914	if (jj_3R_414()) jj_scanpos = xsp;
8915	if (jj_3R_183()) return true;
8916	if (jj_scan_token(RBRACE)) return true;
8917	return false;
8918	}
8919
8920	private boolean jj_3R_434()
8921	{
8922	if (jj_scan_token(SLASH)) return true;
8923	return false;
8924	}
8925
8926	private boolean jj_3R_380()
8927	{
8928	if (jj_3R_121()) return true;
8929	return false;
8930	}
8931
8932	private boolean jj_3R_312()
8933	{
8934	if (jj_scan_token(SWITCH)) return true;
8935	if (jj_scan_token(LPAREN)) return true;
8936	if (jj_3R_93()) return true;
8937	if (jj_scan_token(RPAREN)) return true;
8938	if (jj_scan_token(LBRACE)) return true;
8939	Token xsp;
8940	while (true) {
8941	xsp = jj_scanpos;
8942	if (jj_3R_335()) { jj_scanpos = xsp; break; }
8943	}
8944	if (jj_scan_token(RBRACE)) return true;
8945	return false;
8946	}
8947
8948	private boolean jj_3R_435()
8949	{
8950	if (jj_scan_token(REM)) return true;
8951	return false;
8952	}
8953
8954	private boolean jj_3R_413()
8955	{
8956	if (jj_scan_token(THROWS)) return true;
8957	if (jj_3R_254()) return true;
8958	Token xsp;
8959	while (true) {
8960	xsp = jj_scanpos;
8961	if (jj_3R_425()) { jj_scanpos = xsp; break; }
8962	}
8963	return false;
8964	}
8965
8966	private boolean jj_3R_425()
8967	{
8968	if (jj_scan_token(COMMA)) return true;
8969	if (jj_3R_254()) return true;
8970	return false;
8971	}
8972
8973	private boolean jj_3R_335()
8974	{
8975	if (jj_3R_359()) return true;
8976	return false;
8977	}
8978
8979	private boolean jj_3R_414()
8980	{
8981	if (jj_3R_83()) return true;
8982	return false;
8983	}
8984
8985	private boolean jj_3R_458()
8986	{
8987	if (jj_scan_token(_DEFAULT)) return true;
8988	if (jj_3R_118()) return true;
8989	return false;
8990	}
8991
8992	private boolean jj_3_13()
8993	{
8994	if (jj_3R_83()) return true;
8995	return false;
8996	}
8997
8998	private boolean jj_3R_173()
8999	{
9000	Token xsp;
9001	xsp = jj_scanpos;
9002	if (jj_3R_209()) {
9003	jj_scanpos = xsp;
9004	if (jj_3R_210()) {
9005	jj_scanpos = xsp;
9006	if (jj_3R_211()) {
9007	jj_scanpos = xsp;
9008	if (jj_3R_212()) return true;
9009	}
9010	}
9011	}
9012	return false;
9013	}
9014
9015	private boolean jj_3R_209()
9016	{
9017	if (jj_3R_114()) return true;
9018	return false;
9019	}
9020
9021	private boolean jj_3R_210()
9022	{
9023	if (jj_3R_265()) return true;
9024	return false;
9025	}
9026
9027	private boolean jj_3R_211()
9028	{
9029	Token xsp;
9030	xsp = jj_scanpos;
9031	if (jj_3R_266()) {
9032	jj_scanpos = xsp;
9033	if (jj_3R_267()) return true;
9034	}
9035	if (jj_3R_173()) return true;
9036	return false;
9037	}
9038
9039	private boolean jj_3R_266()
9040	{
9041	if (jj_scan_token(PLUS)) return true;
9042	return false;
9043	}
9044
9045	private boolean jj_3R_267()
9046	{
9047	if (jj_scan_token(MINUS)) return true;
9048	return false;
9049	}
9050
9051	private boolean jj_3R_212()
9052	{
9053	if (jj_3R_203()) return true;
9054	return false;
9055	}
9056
9057	private boolean jj_3R_359()
9058	{
9059	Token xsp;
9060	xsp = jj_scanpos;
9061	if (jj_3R_376()) {
9062	jj_scanpos = xsp;
9063	if (jj_3R_377()) return true;
9064	}
9065	xsp = jj_scanpos;
9066	if (jj_3R_378()) {
9067	jj_scanpos = xsp;
9068	if (jj_3R_379()) return true;
9069	}
9070	return false;
9071	}
9072
9073	private boolean jj_3R_83()
9074	{
9075	Token xsp;
9076	xsp = jj_scanpos;
9077	if (jj_3R_130()) {
9078	jj_scanpos = xsp;
9079	if (jj_3R_131()) return true;
9080	}
9081	return false;
9082	}
9083
9084	private boolean jj_3R_376()
9085	{
9086	if (jj_scan_token(CASE)) return true;
9087	if (jj_3R_152()) return true;
9088	Token xsp;
9089	while (true) {
9090	xsp = jj_scanpos;
9091	if (jj_3R_386()) { jj_scanpos = xsp; break; }
9092	}
9093	return false;
9094	}
9095
9096	private boolean jj_3R_112()
9097	{
9098	Token xsp;
9099	while (true) {
9100	xsp = jj_scanpos;
9101	if (jj_3_3()) { jj_scanpos = xsp; break; }
9102	}
9103	return false;
9104	}
9105
9106	private boolean jj_3R_130()
9107	{
9108	Token xsp;
9109	xsp = jj_scanpos;
9110	if (jj_3R_186()) jj_scanpos = xsp;
9111	if (jj_scan_token(THIS)) return true;
9112	if (jj_3R_187()) return true;
9113	if (jj_scan_token(SEMICOLON)) return true;
9114	return false;
9115	}
9116
9117	private boolean jj_3R_186()
9118	{
9119	if (jj_3R_90()) return true;
9120	return false;
9121	}
9122
9123	private boolean jj_3R_377()
9124	{
9125	if (jj_scan_token(_DEFAULT)) return true;
9126	return false;
9127	}
9128
9129	private boolean jj_3R_386()
9130	{
9131	if (jj_scan_token(COMMA)) return true;
9132	if (jj_3R_152()) return true;
9133	return false;
9134	}
9135
9136	private boolean jj_3_3()
9137	{
9138	Token xsp;
9139	xsp = jj_scanpos;
9140	if (jj_3R_60()) {
9141	jj_scanpos = xsp;
9142	if (jj_3R_61()) {
9143	jj_scanpos = xsp;
9144	if (jj_3R_62()) {
9145	jj_scanpos = xsp;
9146	if (jj_3R_63()) {
9147	jj_scanpos = xsp;
9148	if (jj_3R_64()) {
9149	jj_scanpos = xsp;
9150	if (jj_3R_65()) {
9151	jj_scanpos = xsp;
9152	if (jj_3R_66()) {
9153	jj_scanpos = xsp;
9154	if (jj_3R_67()) {
9155	jj_scanpos = xsp;
9156	if (jj_3R_68()) {
9157	jj_scanpos = xsp;
9158	if (jj_3R_69()) {
9159	jj_scanpos = xsp;
9160	if (jj_3R_70()) {
9161	jj_scanpos = xsp;
9162	if (jj_3R_71()) {
9163	jj_scanpos = xsp;
9164	if (jj_3R_72()) {
9165	jj_scanpos = xsp;
9166	if (jj_3R_73()) return true;
9167	}
9168	}
9169	}
9170	}
9171	}
9172	}
9173	}
9174	}
9175	}
9176	}
9177	}
9178	}
9179	}
9180	return false;
9181	}
9182
9183	private boolean jj_3R_114()
9184	{
9185	if (jj_scan_token(INCR)) return true;
9186	if (jj_3R_173()) return true;
9187	return false;
9188	}
9189
9190	private boolean jj_3R_131()
9191	{
9192	Token xsp;
9193	xsp = jj_scanpos;
9194	if (jj_3R_188()) jj_scanpos = xsp;
9195	xsp = jj_scanpos;
9196	if (jj_3R_189()) jj_scanpos = xsp;
9197	if (jj_scan_token(SUPER)) return true;
9198	if (jj_3R_187()) return true;
9199	if (jj_scan_token(SEMICOLON)) return true;
9200	return false;
9201	}
9202
9203	private boolean jj_3R_378()
9204	{
9205	if (jj_scan_token(COLON)) return true;
9206	if (jj_3R_183()) return true;
9207	return false;
9208	}
9209
9210	private boolean jj_3_58()
9211	{
9212	if (jj_scan_token(REQUIRES)) return true;
9213	if (jj_scan_token(TRANSITIVE)) return true;
9214	if (jj_scan_token(SEMICOLON)) return true;
9215	return false;
9216	}
9217
9218	private boolean jj_3_15()
9219	{
9220	Token xsp;
9221	xsp = jj_scanpos;
9222	if (jj_3R_85()) jj_scanpos = xsp;
9223	if (jj_scan_token(THIS)) return true;
9224	if (jj_scan_token(LPAREN)) return true;
9225	return false;
9226	}
9227
9228	private boolean jj_3R_379()
9229	{
9230	if (jj_scan_token(ARROW)) return true;
9231	Token xsp;
9232	xsp = jj_scanpos;
9233	if (jj_3R_387()) {
9234	jj_scanpos = xsp;
9235	if (jj_3R_388()) {
9236	jj_scanpos = xsp;
9237	if (jj_3R_389()) return true;
9238	}
9239	}
9240	return false;
9241	}
9242
9243	private boolean jj_3R_60()
9244	{
9245	if (jj_scan_token(PUBLIC)) return true;
9246	return false;
9247	}
9248
9249	private boolean jj_3R_188()
9250	{
9251	if (jj_3R_84()) return true;
9252	if (jj_scan_token(DOT)) return true;
9253	return false;
9254	}
9255
9256	private boolean jj_3R_85()
9257	{
9258	if (jj_3R_90()) return true;
9259	return false;
9260	}
9261
9262	private boolean jj_3R_61()
9263	{
9264	if (jj_scan_token(STATIC)) return true;
9265	return false;
9266	}
9267
9268	private boolean jj_3R_62()
9269	{
9270	if (jj_scan_token(PROTECTED)) return true;
9271	return false;
9272	}
9273
9274	private boolean jj_3R_189()
9275	{
9276	if (jj_3R_90()) return true;
9277	return false;
9278	}
9279
9280	private boolean jj_3R_387()
9281	{
9282	if (jj_3R_93()) return true;
9283	if (jj_scan_token(SEMICOLON)) return true;
9284	return false;
9285	}
9286
9287	private boolean jj_3R_63()
9288	{
9289	if (jj_scan_token(PRIVATE)) return true;
9290	return false;
9291	}
9292
9293	private boolean jj_3R_64()
9294	{
9295	if (jj_scan_token(FINAL)) return true;
9296	return false;
9297	}
9298
9299	private boolean jj_3R_65()
9300	{
9301	if (jj_scan_token(ABSTRACT)) return true;
9302	return false;
9303	}
9304
9305	private boolean jj_3_14()
9306	{
9307	if (jj_3R_84()) return true;
9308	if (jj_scan_token(DOT)) return true;
9309	return false;
9310	}
9311
9312	private boolean jj_3R_66()
9313	{
9314	if (jj_scan_token(SYNCHRONIZED)) return true;
9315	return false;
9316	}
9317
9318	private boolean jj_3R_265()
9319	{
9320	if (jj_scan_token(DECR)) return true;
9321	if (jj_3R_173()) return true;
9322	return false;
9323	}
9324
9325	private boolean jj_3R_388()
9326	{
9327	if (jj_3R_126()) return true;
9328	return false;
9329	}
9330
9331	private boolean jj_3R_67()
9332	{
9333	if (jj_scan_token(NATIVE)) return true;
9334	return false;
9335	}
9336
9337	private boolean jj_3R_68()
9338	{
9339	if (jj_scan_token(TRANSIENT)) return true;
9340	return false;
9341	}
9342
9343	private boolean jj_3R_69()
9344	{
9345	if (jj_scan_token(VOLATILE)) return true;
9346	return false;
9347	}
9348
9349	private boolean jj_3R_70()
9350	{
9351	if (jj_scan_token(STRICTFP)) return true;
9352	return false;
9353	}
9354
9355	private boolean jj_3R_389()
9356	{
9357	if (jj_3R_303()) return true;
9358	return false;
9359	}
9360
9361	private boolean jj_3R_71()
9362	{
9363	if (jj_scan_token(TRANSITIVE)) return true;
9364	return false;
9365	}
9366
9367	private boolean jj_3R_72()
9368	{
9369	if (jj_scan_token(_DEFAULT)) return true;
9370	return false;
9371	}
9372
9373	private boolean jj_3R_73()
9374	{
9375	if (jj_3R_119()) return true;
9376	return false;
9377	}
9378
9379	private boolean jj_3R_203()
9380	{
9381	Token xsp;
9382	xsp = jj_scanpos;
9383	if (jj_3R_255()) {
9384	jj_scanpos = xsp;
9385	if (jj_3R_256()) {
9386	jj_scanpos = xsp;
9387	if (jj_3R_257()) {
9388	jj_scanpos = xsp;
9389	if (jj_3R_258()) return true;
9390	}
9391	}
9392	}
9393	return false;
9394	}
9395
9396	private boolean jj_3R_255()
9397	{
9398	Token xsp;
9399	xsp = jj_scanpos;
9400	if (jj_3R_309()) {
9401	jj_scanpos = xsp;
9402	if (jj_3R_310()) return true;
9403	}
9404	if (jj_3R_173()) return true;
9405	return false;
9406	}
9407
9408	private boolean jj_3R_183()
9409	{
9410	Token xsp;
9411	while (true) {
9412	xsp = jj_scanpos;
9413	if (jj_3_16()) { jj_scanpos = xsp; break; }
9414	}
9415	return false;
9416	}
9417
9418	private boolean jj_3_16()
9419	{
9420	if (jj_3R_86()) return true;
9421	return false;
9422	}
9423
9424	private boolean jj_3R_309()
9425	{
9426	if (jj_scan_token(TILDE)) return true;
9427	return false;
9428	}
9429
9430	private boolean jj_3R_256()
9431	{
9432	if (jj_3R_97()) return true;
9433	return false;
9434	}
9435
9436	private boolean jj_3R_296()
9437	{
9438	if (jj_scan_token(IF)) return true;
9439	if (jj_scan_token(LPAREN)) return true;
9440	if (jj_3R_93()) return true;
9441	if (jj_scan_token(RPAREN)) return true;
9442	if (jj_3R_199()) return true;
9443	Token xsp;
9444	xsp = jj_scanpos;
9445	if (jj_3R_430()) jj_scanpos = xsp;
9446	return false;
9447	}
9448
9449	private boolean jj_3R_310()
9450	{
9451	if (jj_scan_token(BANG)) return true;
9452	return false;
9453	}
9454
9455	private boolean jj_3R_257()
9456	{
9457	if (jj_3R_311()) return true;
9458	return false;
9459	}
9460
9461	private boolean jj_3R_258()
9462	{
9463	if (jj_3R_312()) return true;
9464	return false;
9465	}
9466
9467	private boolean jj_3R_430()
9468	{
9469	if (jj_scan_token(ELSE)) return true;
9470	if (jj_3R_199()) return true;
9471	return false;
9472	}
9473
9474	private boolean jj_3_28()
9475	{
9476	if (jj_3R_97()) return true;
9477	return false;
9478	}
9479
9480	private boolean jj_3R_79()
9481	{
9482	Token xsp;
9483	xsp = jj_scanpos;
9484	if (jj_3R_125()) jj_scanpos = xsp;
9485	if (jj_3R_126()) return true;
9486	return false;
9487	}
9488
9489	private boolean jj_3R_125()
9490	{
9491	if (jj_scan_token(STATIC)) return true;
9492	return false;
9493	}
9494
9495	private boolean jj_3R_198()
9496	{
9497	Token xsp;
9498	xsp = jj_scanpos;
9499	if (jj_3R_231()) {
9500	jj_scanpos = xsp;
9501	if (jj_3R_232()) return true;
9502	}
9503	if (jj_3R_91()) return true;
9504	xsp = jj_scanpos;
9505	if (jj_3R_268()) jj_scanpos = xsp;
9506	xsp = jj_scanpos;
9507	if (jj_3R_269()) jj_scanpos = xsp;
9508	xsp = jj_scanpos;
9509	if (jj_3R_270()) jj_scanpos = xsp;
9510	if (jj_3R_108()) return true;
9511	return false;
9512	}
9513
9514	private boolean jj_3R_311()
9515	{
9516	if (jj_3R_213()) return true;
9517	Token xsp;
9518	xsp = jj_scanpos;
9519	if (jj_3_29()) jj_scanpos = xsp;
9520	return false;
9521	}
9522
9523	private boolean jj_3R_231()
9524	{
9525	if (jj_scan_token(CLASS)) return true;
9526	return false;
9527	}
9528
9529	private boolean jj_3_29()
9530	{
9531	Token xsp;
9532	xsp = jj_scanpos;
9533	if (jj_3R_98()) {
9534	jj_scanpos = xsp;
9535	if (jj_3R_99()) return true;
9536	}
9537	return false;
9538	}
9539
9540	private boolean jj_3R_232()
9541	{
9542	if (jj_scan_token(INTERFACE)) return true;
9543	return false;
9544	}
9545
9546	private boolean jj_3R_268()
9547	{
9548	if (jj_3R_121()) return true;
9549	return false;
9550	}
9551
9552	private boolean jj_3R_297()
9553	{
9554	if (jj_scan_token(WHILE)) return true;
9555	if (jj_scan_token(LPAREN)) return true;
9556	if (jj_3R_93()) return true;
9557	if (jj_scan_token(RPAREN)) return true;
9558	if (jj_3R_199()) return true;
9559	return false;
9560	}
9561
9562	private boolean jj_3R_269()
9563	{
9564	if (jj_3R_315()) return true;
9565	return false;
9566	}
9567
9568	private boolean jj_3R_270()
9569	{
9570	if (jj_3R_316()) return true;
9571	return false;
9572	}
9573
9574	private boolean jj_3R_98()
9575	{
9576	if (jj_scan_token(INCR)) return true;
9577	return false;
9578	}
9579
9580	private boolean jj_3R_99()
9581	{
9582	if (jj_scan_token(DECR)) return true;
9583	return false;
9584	}
9585
9586	private boolean jj_3_59()
9587	{
9588	if (jj_3R_86()) return true;
9589	return false;
9590	}
9591
9592	private boolean jj_3R_77()
9593	{
9594	Token xsp;
9595	xsp = jj_scanpos;
9596	if (jj_3R_122()) {
9597	jj_scanpos = xsp;
9598	if (jj_3R_123()) return true;
9599	}
9600	return false;
9601	}
9602
9603	private boolean jj_3R_122()
9604	{
9605	if (jj_3R_182()) return true;
9606	return false;
9607	}
9608
9609	private boolean jj_3R_123()
9610	{
9611	if (jj_3R_100()) return true;
9612	return false;
9613	}
9614
9615	private boolean jj_3R_298()
9616	{
9617	if (jj_scan_token(DO)) return true;
9618	if (jj_3R_199()) return true;
9619	if (jj_scan_token(WHILE)) return true;
9620	if (jj_scan_token(LPAREN)) return true;
9621	if (jj_3R_93()) return true;
9622	if (jj_scan_token(RPAREN)) return true;
9623	if (jj_scan_token(SEMICOLON)) return true;
9624	return false;
9625	}
9626
9627	private boolean jj_3_17()
9628	{
9629	Token xsp;
9630	xsp = jj_scanpos;
9631	if (jj_3R_87()) {
9632	jj_scanpos = xsp;
9633	if (jj_3R_88()) return true;
9634	}
9635	return false;
9636	}
9637
9638	private boolean jj_3R_87()
9639	{
9640	if (jj_3R_100()) return true;
9641	if (jj_3R_89()) return true;
9642	if (jj_scan_token(LBRACKET)) return true;
9643	return false;
9644	}
9645
9646	private boolean jj_3R_97()
9647	{
9648	if (jj_scan_token(LPAREN)) return true;
9649	if (jj_3R_89()) return true;
9650	Token xsp;
9651	xsp = jj_scanpos;
9652	if (jj_3_30()) {
9653	jj_scanpos = xsp;
9654	if (jj_3R_155()) return true;
9655	}
9656	return false;
9657	}
9658
9659	private boolean jj_3R_315()
9660	{
9661	if (jj_scan_token(EXTENDS)) return true;
9662	if (jj_3R_317()) return true;
9663	Token xsp;
9664	while (true) {
9665	xsp = jj_scanpos;
9666	if (jj_3R_427()) { jj_scanpos = xsp; break; }
9667	}
9668	return false;
9669	}
9670
9671	private boolean jj_3_30()
9672	{
9673	if (jj_3R_100()) return true;
9674	if (jj_scan_token(RPAREN)) return true;
9675	if (jj_3R_173()) return true;
9676	return false;
9677	}
9678
9679	private boolean jj_3R_427()
9680	{
9681	if (jj_scan_token(COMMA)) return true;
9682	if (jj_3R_317()) return true;
9683	return false;
9684	}
9685
9686	private boolean jj_3R_155()
9687	{
9688	if (jj_3R_182()) return true;
9689	Token xsp;
9690	while (true) {
9691	xsp = jj_scanpos;
9692	if (jj_3R_202()) { jj_scanpos = xsp; break; }
9693	}
9694	if (jj_scan_token(RPAREN)) return true;
9695	if (jj_3R_203()) return true;
9696	return false;
9697	}
9698
9699	private boolean jj_3R_202()
9700	{
9701	if (jj_scan_token(BIT_AND)) return true;
9702	if (jj_3R_254()) return true;
9703	return false;
9704	}
9705
9706	private boolean jj_3R_299()
9707	{
9708	if (jj_scan_token(FOR)) return true;
9709	if (jj_scan_token(LPAREN)) return true;
9710	Token xsp;
9711	xsp = jj_scanpos;
9712	if (jj_3R_348()) {
9713	jj_scanpos = xsp;
9714	if (jj_3R_349()) return true;
9715	}
9716	if (jj_scan_token(RPAREN)) return true;
9717	if (jj_3R_199()) return true;
9718	return false;
9719	}
9720
9721	private boolean jj_3R_182()
9722	{
9723	Token xsp;
9724	xsp = jj_scanpos;
9725	if (jj_3R_216()) {
9726	jj_scanpos = xsp;
9727	if (jj_3R_217()) return true;
9728	}
9729	return false;
9730	}
9731
9732	private boolean jj_3R_216()
9733	{
9734	if (jj_3R_100()) return true;
9735	Token xsp;
9736	if (jj_3R_272()) return true;
9737	while (true) {
9738	xsp = jj_scanpos;
9739	if (jj_3R_272()) { jj_scanpos = xsp; break; }
9740	}
9741	return false;
9742	}
9743
9744	private boolean jj_3R_348()
9745	{
9746	if (jj_3R_113()) return true;
9747	if (jj_scan_token(COLON)) return true;
9748	if (jj_3R_93()) return true;
9749	return false;
9750	}
9751
9752	private boolean jj_3R_316()
9753	{
9754	if (jj_scan_token(IMPLEMENTS)) return true;
9755	if (jj_3R_317()) return true;
9756	Token xsp;
9757	while (true) {
9758	xsp = jj_scanpos;
9759	if (jj_3R_428()) { jj_scanpos = xsp; break; }
9760	}
9761	return false;
9762	}
9763
9764	private boolean jj_3R_217()
9765	{
9766	if (jj_3R_137()) return true;
9767	Token xsp;
9768	while (true) {
9769	xsp = jj_scanpos;
9770	if (jj_3R_273()) { jj_scanpos = xsp; break; }
9771	}
9772	return false;
9773	}
9774
9775	private boolean jj_3R_272()
9776	{
9777	if (jj_3R_124()) return true;
9778	return false;
9779	}
9780
9781	private boolean jj_3R_349()
9782	{
9783	Token xsp;
9784	xsp = jj_scanpos;
9785	if (jj_3R_368()) jj_scanpos = xsp;
9786	if (jj_scan_token(SEMICOLON)) return true;
9787	xsp = jj_scanpos;
9788	if (jj_3R_443()) jj_scanpos = xsp;
9789	if (jj_scan_token(SEMICOLON)) return true;
9790	xsp = jj_scanpos;
9791	if (jj_3R_444()) jj_scanpos = xsp;
9792	return false;
9793	}
9794
9795	private boolean jj_3R_368()
9796	{
9797	if (jj_3R_383()) return true;
9798	return false;
9799	}
9800
9801	private boolean jj_3R_428()
9802	{
9803	if (jj_scan_token(COMMA)) return true;
9804	if (jj_3R_317()) return true;
9805	return false;
9806	}
9807
9808	private boolean jj_3_46()
9809	{
9810	if (jj_3R_113()) return true;
9811	if (jj_scan_token(COLON)) return true;
9812	return false;
9813	}
9814
9815	private boolean jj_3R_443()
9816	{
9817	if (jj_3R_93()) return true;
9818	return false;
9819	}
9820
9821	private boolean jj_3R_88()
9822	{
9823	if (jj_3R_137()) return true;
9824	return false;
9825	}
9826
9827	private boolean jj_3R_273()
9828	{
9829	if (jj_3R_124()) return true;
9830	return false;
9831	}
9832
9833	private boolean jj_3R_444()
9834	{
9835	if (jj_3R_448()) return true;
9836	return false;
9837	}
9838
9839	private boolean jj_3_18()
9840	{
9841	if (jj_3R_89()) return true;
9842	if (jj_scan_token(LBRACKET)) return true;
9843	return false;
9844	}
9845
9846	private boolean jj_3_19()
9847	{
9848	if (jj_3R_89()) return true;
9849	if (jj_scan_token(LBRACKET)) return true;
9850	return false;
9851	}
9852
9853	private boolean jj_3R_213()
9854	{
9855	if (jj_3R_132()) return true;
9856	Token xsp;
9857	while (true) {
9858	xsp = jj_scanpos;
9859	if (jj_3_31()) { jj_scanpos = xsp; break; }
9860	}
9861	return false;
9862	}
9863
9864	private boolean jj_3_31()
9865	{
9866	if (jj_3R_101()) return true;
9867	return false;
9868	}
9869
9870	private boolean jj_3R_124()
9871	{
9872	if (jj_3R_89()) return true;
9873	if (jj_scan_token(LBRACKET)) return true;
9874	if (jj_scan_token(RBRACKET)) return true;
9875	return false;
9876	}
9877
9878	private boolean jj_3R_84()
9879	{
9880	if (jj_3R_132()) return true;
9881	Token xsp;
9882	while (true) {
9883	xsp = jj_scanpos;
9884	if (jj_3R_133()) { jj_scanpos = xsp; break; }
9885	}
9886	return false;
9887	}
9888
9889	private boolean jj_3R_133()
9890	{
9891	if (jj_3R_102()) return true;
9892	return false;
9893	}
9894
9895	private boolean jj_3R_383()
9896	{
9897	Token xsp;
9898	xsp = jj_scanpos;
9899	if (jj_3R_391()) {
9900	jj_scanpos = xsp;
9901	if (jj_3R_392()) return true;
9902	}
9903	return false;
9904	}
9905
9906	private boolean jj_3R_362()
9907	{
9908	if (jj_scan_token(ENUM)) return true;
9909	if (jj_3R_91()) return true;
9910	Token xsp;
9911	xsp = jj_scanpos;
9912	if (jj_3R_408()) jj_scanpos = xsp;
9913	if (jj_scan_token(LBRACE)) return true;
9914	xsp = jj_scanpos;
9915	if (jj_3R_409()) jj_scanpos = xsp;
9916	xsp = jj_scanpos;
9917	if (jj_scan_token(103)) jj_scanpos = xsp;
9918	xsp = jj_scanpos;
9919	if (jj_3R_410()) jj_scanpos = xsp;
9920	if (jj_scan_token(RBRACE)) return true;
9921	return false;
9922	}
9923
9924	private boolean jj_3R_391()
9925	{
9926	if (jj_3R_113()) return true;
9927	return false;
9928	}
9929
9930	private boolean jj_3R_408()
9931	{
9932	if (jj_3R_316()) return true;
9933	return false;
9934	}
9935
9936	private boolean jj_3R_392()
9937	{
9938	if (jj_3R_395()) return true;
9939	return false;
9940	}
9941
9942	private boolean jj_3_32()
9943	{
9944	if (jj_3R_102()) return true;
9945	return false;
9946	}
9947
9948	private boolean jj_3R_409()
9949	{
9950	if (jj_3R_74()) return true;
9951	Token xsp;
9952	while (true) {
9953	xsp = jj_scanpos;
9954	if (jj_3_4()) { jj_scanpos = xsp; break; }
9955	}
9956	return false;
9957	}
9958
9959	private boolean jj_3_4()
9960	{
9961	if (jj_scan_token(COMMA)) return true;
9962	if (jj_3R_74()) return true;
9963	return false;
9964	}
9965
9966	private boolean jj_3R_317()
9967	{
9968	if (jj_3R_89()) return true;
9969	if (jj_3R_137()) return true;
9970	return false;
9971	}
9972
9973	private boolean jj_3_47()
9974	{
9975	if (jj_3R_112()) return true;
9976	if (jj_3R_77()) return true;
9977	if (jj_3R_76()) return true;
9978	return false;
9979	}
9980
9981	private boolean jj_3R_410()
9982	{
9983	if (jj_scan_token(SEMICOLON)) return true;
9984	Token xsp;
9985	while (true) {
9986	xsp = jj_scanpos;
9987	if (jj_3R_422()) { jj_scanpos = xsp; break; }
9988	}
9989	return false;
9990	}
9991
9992	private boolean jj_3R_132()
9993	{
9994	Token xsp;
9995	xsp = jj_scanpos;
9996	if (jj_3R_190()) {
9997	jj_scanpos = xsp;
9998	if (jj_3R_191()) {
9999	jj_scanpos = xsp;
10000	if (jj_3R_192()) {
10001	jj_scanpos = xsp;
10002	if (jj_3R_193()) {
10003	jj_scanpos = xsp;
10004	if (jj_3R_194()) {
10005	jj_scanpos = xsp;
10006	if (jj_3R_195()) {
10007	jj_scanpos = xsp;
10008	if (jj_3R_196()) {
10009	jj_scanpos = xsp;
10010	if (jj_3R_197()) return true;
10011	}
10012	}
10013	}
10014	}
10015	}
10016	}
10017	}
10018	return false;
10019	}
10020
10021	private boolean jj_3R_422()
10022	{
10023	Token xsp;
10024	xsp = jj_scanpos;
10025	if (jj_3R_438()) {
10026	jj_scanpos = xsp;
10027	if (jj_scan_token(102)) return true;
10028	}
10029	return false;
10030	}
10031
10032	private boolean jj_3R_438()
10033	{
10034	if (jj_3R_261()) return true;
10035	return false;
10036	}
10037
10038	private boolean jj_3R_190()
10039	{
10040	if (jj_3R_219()) return true;
10041	return false;
10042	}
10043
10044	private boolean jj_3R_191()
10045	{
10046	if (jj_scan_token(THIS)) return true;
10047	return false;
10048	}
10049
10050	private boolean jj_3R_192()
10051	{
10052	if (jj_scan_token(SUPER)) return true;
10053	Token xsp;
10054	xsp = jj_scanpos;
10055	if (jj_3R_220()) {
10056	jj_scanpos = xsp;
10057	if (jj_3R_221()) return true;
10058	}
10059	return false;
10060	}
10061
10062	private boolean jj_3R_137()
10063	{
10064	if (jj_3R_91()) return true;
10065	Token xsp;
10066	xsp = jj_scanpos;
10067	if (jj_3_20()) jj_scanpos = xsp;
10068	while (true) {
10069	xsp = jj_scanpos;
10070	if (jj_3_21()) { jj_scanpos = xsp; break; }
10071	}
10072	return false;
10073	}
10074
10075	private boolean jj_3R_395()
10076	{
10077	if (jj_3R_93()) return true;
10078	Token xsp;
10079	while (true) {
10080	xsp = jj_scanpos;
10081	if (jj_3R_456()) { jj_scanpos = xsp; break; }
10082	}
10083	return false;
10084	}
10085
10086	private boolean jj_3_20()
10087	{
10088	if (jj_3R_90()) return true;
10089	return false;
10090	}
10091
10092	private boolean jj_3R_220()
10093	{
10094	if (jj_scan_token(DOT)) return true;
10095	Token xsp;
10096	xsp = jj_scanpos;
10097	if (jj_3R_283()) jj_scanpos = xsp;
10098	if (jj_3R_91()) return true;
10099	xsp = jj_scanpos;
10100	if (jj_3R_284()) jj_scanpos = xsp;
10101	return false;
10102	}
10103
10104	private boolean jj_3R_283()
10105	{
10106	if (jj_3R_90()) return true;
10107	return false;
10108	}
10109
10110	private boolean jj_3R_456()
10111	{
10112	if (jj_scan_token(COMMA)) return true;
10113	if (jj_3R_93()) return true;
10114	return false;
10115	}
10116
10117	private boolean jj_3R_284()
10118	{
10119	if (jj_3R_187()) return true;
10120	return false;
10121	}
10122
10123	private boolean jj_3_21()
10124	{
10125	if (jj_scan_token(DOT)) return true;
10126	if (jj_3R_89()) return true;
10127	if (jj_3R_91()) return true;
10128	Token xsp;
10129	xsp = jj_scanpos;
10130	if (jj_3_22()) jj_scanpos = xsp;
10131	return false;
10132	}
10133
10134	private boolean jj_3_22()
10135	{
10136	if (jj_3R_90()) return true;
10137	return false;
10138	}
10139
10140	private boolean jj_3R_221()
10141	{
10142	if (jj_scan_token(DOUBLECOLON)) return true;
10143	Token xsp;
10144	xsp = jj_scanpos;
10145	if (jj_3R_285()) jj_scanpos = xsp;
10146	xsp = jj_scanpos;
10147	if (jj_3R_286()) {
10148	jj_scanpos = xsp;
10149	if (jj_scan_token(42)) return true;
10150	}
10151	return false;
10152	}
10153
10154	private boolean jj_3R_285()
10155	{
10156	if (jj_3R_90()) return true;
10157	return false;
10158	}
10159
10160	private boolean jj_3R_286()
10161	{
10162	if (jj_3R_76()) return true;
10163	return false;
10164	}
10165
10166	private boolean jj_3R_74()
10167	{
10168	Token xsp;
10169	while (true) {
10170	xsp = jj_scanpos;
10171	if (jj_3R_120()) { jj_scanpos = xsp; break; }
10172	}
10173	if (jj_3R_91()) return true;
10174	xsp = jj_scanpos;
10175	if (jj_3R_436()) jj_scanpos = xsp;
10176	xsp = jj_scanpos;
10177	if (jj_3R_437()) jj_scanpos = xsp;
10178	return false;
10179	}
10180
10181	private boolean jj_3R_193()
10182	{
10183	if (jj_scan_token(LPAREN)) return true;
10184	Token xsp;
10185	xsp = jj_scanpos;
10186	if (jj_3R_222()) {
10187	jj_scanpos = xsp;
10188	if (jj_3R_223()) {
10189	jj_scanpos = xsp;
10190	if (jj_3R_224()) {
10191	jj_scanpos = xsp;
10192	if (jj_3R_225()) return true;
10193	}
10194	}
10195	}
10196	return false;
10197	}
10198
10199	private boolean jj_3R_120()
10200	{
10201	if (jj_3R_119()) return true;
10202	return false;
10203	}
10204
10205	private boolean jj_3R_436()
10206	{
10207	if (jj_3R_187()) return true;
10208	return false;
10209	}
10210
10211	private boolean jj_3R_437()
10212	{
10213	if (jj_3R_108()) return true;
10214	return false;
10215	}
10216
10217	private boolean jj_3R_222()
10218	{
10219	if (jj_scan_token(RPAREN)) return true;
10220	return false;
10221	}
10222
10223	private boolean jj_3R_223()
10224	{
10225	if (jj_3R_287()) return true;
10226	if (jj_scan_token(RPAREN)) return true;
10227	return false;
10228	}
10229
10230	private boolean jj_3R_448()
10231	{
10232	if (jj_3R_395()) return true;
10233	return false;
10234	}
10235
10236	private boolean jj_3R_224()
10237	{
10238	if (jj_3R_288()) return true;
10239	if (jj_scan_token(RPAREN)) return true;
10240	return false;
10241	}
10242
10243	private boolean jj_3R_90()
10244	{
10245	if (jj_scan_token(LT)) return true;
10246	Token xsp;
10247	xsp = jj_scanpos;
10248	if (jj_3R_139()) jj_scanpos = xsp;
10249	if (jj_scan_token(GT)) return true;
10250	return false;
10251	}
10252
10253	private boolean jj_3_33()
10254	{
10255	if (jj_3R_103()) return true;
10256	return false;
10257	}
10258
10259	private boolean jj_3R_225()
10260	{
10261	if (jj_3R_93()) return true;
10262	if (jj_scan_token(RPAREN)) return true;
10263	return false;
10264	}
10265
10266	private boolean jj_3R_139()
10267	{
10268	if (jj_3R_200()) return true;
10269	Token xsp;
10270	while (true) {
10271	xsp = jj_scanpos;
10272	if (jj_3R_230()) { jj_scanpos = xsp; break; }
10273	}
10274	return false;
10275	}
10276
10277	private boolean jj_3R_194()
10278	{
10279	if (jj_3R_226()) return true;
10280	return false;
10281	}
10282
10283	private boolean jj_3R_195()
10284	{
10285	if (jj_3R_105()) return true;
10286	if (jj_scan_token(DOT)) return true;
10287	if (jj_scan_token(CLASS)) return true;
10288	return false;
10289	}
10290
10291	private boolean jj_3_34()
10292	{
10293	if (jj_3R_104()) return true;
10294	if (jj_scan_token(COMMA)) return true;
10295	return false;
10296	}
10297
10298	private boolean jj_3R_230()
10299	{
10300	if (jj_scan_token(COMMA)) return true;
10301	if (jj_3R_200()) return true;
10302	return false;
10303	}
10304
10305	private boolean jj_3R_196()
10306	{
10307	if (jj_3R_106()) return true;
10308	if (jj_scan_token(DOUBLECOLON)) return true;
10309	Token xsp;
10310	xsp = jj_scanpos;
10311	if (jj_3R_227()) jj_scanpos = xsp;
10312	xsp = jj_scanpos;
10313	if (jj_3R_228()) {
10314	jj_scanpos = xsp;
10315	if (jj_scan_token(42)) return true;
10316	}
10317	return false;
10318	}
10319
10320	private boolean jj_3R_300()
10321	{
10322	if (jj_scan_token(BREAK)) return true;
10323	Token xsp;
10324	xsp = jj_scanpos;
10325	if (jj_3R_329()) jj_scanpos = xsp;
10326	if (jj_scan_token(SEMICOLON)) return true;
10327	return false;
10328	}
10329
10330	private boolean jj_3R_329()
10331	{
10332	if (jj_3R_91()) return true;
10333	return false;
10334	}
10335
10336	private boolean jj_3R_227()
10337	{
10338	if (jj_3R_90()) return true;
10339	return false;
10340	}
10341
10342	private boolean jj_3_35()
10343	{
10344	if (jj_3R_105()) return true;
10345	if (jj_scan_token(DOT)) return true;
10346	if (jj_scan_token(CLASS)) return true;
10347	return false;
10348	}
10349
10350	private boolean jj_3R_228()
10351	{
10352	if (jj_3R_76()) return true;
10353	return false;
10354	}
10355
10356	private boolean jj_3R_197()
10357	{
10358	if (jj_3R_91()) return true;
10359	Token xsp;
10360	xsp = jj_scanpos;
10361	if (jj_3R_229()) jj_scanpos = xsp;
10362	return false;
10363	}
10364
10365	private boolean jj_3_36()
10366	{
10367	if (jj_3R_106()) return true;
10368	if (jj_scan_token(DOUBLECOLON)) return true;
10369	return false;
10370	}
10371
10372	private boolean jj_3R_121()
10373	{
10374	if (jj_scan_token(LT)) return true;
10375	if (jj_3R_89()) return true;
10376	if (jj_3R_180()) return true;
10377	Token xsp;
10378	while (true) {
10379	xsp = jj_scanpos;
10380	if (jj_3R_181()) { jj_scanpos = xsp; break; }
10381	}
10382	if (jj_scan_token(GT)) return true;
10383	return false;
10384	}
10385
10386	private boolean jj_3R_200()
10387	{
10388	if (jj_3R_89()) return true;
10389	Token xsp;
10390	xsp = jj_scanpos;
10391	if (jj_3R_251()) {
10392	jj_scanpos = xsp;
10393	if (jj_3R_252()) return true;
10394	}
10395	return false;
10396	}
10397
10398	private boolean jj_3R_229()
10399	{
10400	if (jj_3R_187()) return true;
10401	return false;
10402	}
10403
10404	private boolean jj_3R_111()
10405	{
10406	if (jj_scan_token(YIELD)) return true;
10407	if (jj_3R_93()) return true;
10408	if (jj_scan_token(SEMICOLON)) return true;
10409	return false;
10410	}
10411
10412	private boolean jj_3R_251()
10413	{
10414	if (jj_3R_77()) return true;
10415	return false;
10416	}
10417
10418	private boolean jj_3R_181()
10419	{
10420	if (jj_scan_token(COMMA)) return true;
10421	if (jj_3R_89()) return true;
10422	if (jj_3R_180()) return true;
10423	return false;
10424	}
10425
10426	private boolean jj_3R_252()
10427	{
10428	if (jj_3R_307()) return true;
10429	return false;
10430	}
10431
10432	private boolean jj_3R_101()
10433	{
10434	Token xsp;
10435	xsp = jj_scanpos;
10436	if (jj_3_37()) {
10437	jj_scanpos = xsp;
10438	if (jj_3R_164()) return true;
10439	}
10440	return false;
10441	}
10442
10443	private boolean jj_3_37()
10444	{
10445	if (jj_3R_102()) return true;
10446	return false;
10447	}
10448
10449	private boolean jj_3R_164()
10450	{
10451	if (jj_scan_token(DOT)) return true;
10452	if (jj_scan_token(SUPER)) return true;
10453	return false;
10454	}
10455
10456	private boolean jj_3R_301()
10457	{
10458	if (jj_scan_token(CONTINUE)) return true;
10459	Token xsp;
10460	xsp = jj_scanpos;
10461	if (jj_3R_330()) jj_scanpos = xsp;
10462	if (jj_scan_token(SEMICOLON)) return true;
10463	return false;
10464	}
10465
10466	private boolean jj_3R_307()
10467	{
10468	if (jj_scan_token(HOOK)) return true;
10469	Token xsp;
10470	xsp = jj_scanpos;
10471	if (jj_3R_353()) jj_scanpos = xsp;
10472	return false;
10473	}
10474
10475	private boolean jj_3R_330()
10476	{
10477	if (jj_3R_91()) return true;
10478	return false;
10479	}
10480
10481	private boolean jj_3R_353()
10482	{
10483	Token xsp;
10484	xsp = jj_scanpos;
10485	if (jj_3R_369()) {
10486	jj_scanpos = xsp;
10487	if (jj_3R_370()) return true;
10488	}
10489	return false;
10490	}
10491
10492	private boolean jj_3R_369()
10493	{
10494	if (jj_scan_token(EXTENDS)) return true;
10495	if (jj_3R_89()) return true;
10496	if (jj_3R_182()) return true;
10497	return false;
10498	}
10499
10500	private boolean jj_3R_180()
10501	{
10502	if (jj_3R_91()) return true;
10503	Token xsp;
10504	xsp = jj_scanpos;
10505	if (jj_3R_215()) jj_scanpos = xsp;
10506	return false;
10507	}
10508
10509	private boolean jj_3R_102()
10510	{
10511	Token xsp;
10512	xsp = jj_scanpos;
10513	if (jj_3R_165()) {
10514	jj_scanpos = xsp;
10515	if (jj_3R_166()) return true;
10516	}
10517	return false;
10518	}
10519
10520	private boolean jj_3R_370()
10521	{
10522	if (jj_scan_token(SUPER)) return true;
10523	if (jj_3R_89()) return true;
10524	if (jj_3R_182()) return true;
10525	return false;
10526	}
10527
10528	private boolean jj_3R_215()
10529	{
10530	if (jj_3R_271()) return true;
10531	return false;
10532	}
10533
10534	private boolean jj_3R_165()
10535	{
10536	if (jj_scan_token(DOT)) return true;
10537	Token xsp;
10538	xsp = jj_scanpos;
10539	if (jj_3R_204()) {
10540	jj_scanpos = xsp;
10541	if (jj_3R_205()) {
10542	jj_scanpos = xsp;
10543	if (jj_3R_206()) return true;
10544	}
10545	}
10546	return false;
10547	}
10548
10549	private boolean jj_3R_302()
10550	{
10551	if (jj_scan_token(RETURN)) return true;
10552	Token xsp;
10553	xsp = jj_scanpos;
10554	if (jj_3R_331()) jj_scanpos = xsp;
10555	if (jj_scan_token(SEMICOLON)) return true;
10556	return false;
10557	}
10558
10559	private boolean jj_3R_331()
10560	{
10561	if (jj_3R_93()) return true;
10562	return false;
10563	}
10564
10565	private boolean jj_3R_204()
10566	{
10567	if (jj_scan_token(THIS)) return true;
10568	return false;
10569	}
10570
10571	private boolean jj_3R_205()
10572	{
10573	if (jj_3R_226()) return true;
10574	return false;
10575	}
10576
10577	private boolean jj_3R_206()
10578	{
10579	Token xsp;
10580	xsp = jj_scanpos;
10581	if (jj_3R_259()) jj_scanpos = xsp;
10582	if (jj_3R_91()) return true;
10583	xsp = jj_scanpos;
10584	if (jj_3R_260()) jj_scanpos = xsp;
10585	return false;
10586	}
10587
10588	private boolean jj_3R_259()
10589	{
10590	if (jj_3R_90()) return true;
10591	return false;
10592	}
10593
10594	private boolean jj_3R_260()
10595	{
10596	if (jj_3R_187()) return true;
10597	return false;
10598	}
10599
10600	private boolean jj_3R_166()
10601	{
10602	if (jj_scan_token(LBRACKET)) return true;
10603	if (jj_3R_93()) return true;
10604	if (jj_scan_token(RBRACKET)) return true;
10605	return false;
10606	}
10607
10608	private boolean jj_3R_100()
10609	{
10610	Token xsp;
10611	xsp = jj_scanpos;
10612	if (jj_3R_156()) {
10613	jj_scanpos = xsp;
10614	if (jj_3R_157()) {
10615	jj_scanpos = xsp;
10616	if (jj_3R_158()) {
10617	jj_scanpos = xsp;
10618	if (jj_3R_159()) {
10619	jj_scanpos = xsp;
10620	if (jj_3R_160()) {
10621	jj_scanpos = xsp;
10622	if (jj_3R_161()) {
10623	jj_scanpos = xsp;
10624	if (jj_3R_162()) {
10625	jj_scanpos = xsp;
10626	if (jj_3R_163()) return true;
10627	}
10628	}
10629	}
10630	}
10631	}
10632	}
10633	}
10634	return false;
10635	}
10636
10637	private boolean jj_3R_303()
10638	{
10639	if (jj_scan_token(THROW)) return true;
10640	if (jj_3R_93()) return true;
10641	if (jj_scan_token(SEMICOLON)) return true;
10642	return false;
10643	}
10644
10645	private boolean jj_3_38()
10646	{
10647	Token xsp;
10648	xsp = jj_scanpos;
10649	if (jj_3R_107()) jj_scanpos = xsp;
10650	if (jj_3R_76()) return true;
10651	return false;
10652	}
10653
10654	private boolean jj_3R_107()
10655	{
10656	if (jj_3R_90()) return true;
10657	return false;
10658	}
10659
10660	private boolean jj_3R_156()
10661	{
10662	if (jj_scan_token(BOOLEAN)) return true;
10663	return false;
10664	}
10665
10666	private boolean jj_3R_157()
10667	{
10668	if (jj_scan_token(CHAR)) return true;
10669	return false;
10670	}
10671
10672	private boolean jj_3R_158()
10673	{
10674	if (jj_scan_token(BYTE)) return true;
10675	return false;
10676	}
10677
10678	private boolean jj_3R_271()
10679	{
10680	if (jj_scan_token(EXTENDS)) return true;
10681	if (jj_3R_317()) return true;
10682	Token xsp;
10683	while (true) {
10684	xsp = jj_scanpos;
10685	if (jj_3R_318()) { jj_scanpos = xsp; break; }
10686	}
10687	return false;
10688	}
10689
10690	private boolean jj_3R_159()
10691	{
10692	if (jj_scan_token(SHORT)) return true;
10693	return false;
10694	}
10695
10696	private boolean jj_3R_160()
10697	{
10698	if (jj_scan_token(INT)) return true;
10699	return false;
10700	}
10701
10702	private boolean jj_3R_161()
10703	{
10704	if (jj_scan_token(LONG)) return true;
10705	return false;
10706	}
10707
10708	private boolean jj_3R_318()
10709	{
10710	if (jj_scan_token(BIT_AND)) return true;
10711	if (jj_3R_317()) return true;
10712	return false;
10713	}
10714
10715	private boolean jj_3R_162()
10716	{
10717	if (jj_scan_token(FLOAT)) return true;
10718	return false;
10719	}
10720
10721	private boolean jj_3R_163()
10722	{
10723	if (jj_scan_token(DOUBLE)) return true;
10724	return false;
10725	}
10726
10727	private boolean jj_3R_304()
10728	{
10729	if (jj_scan_token(SYNCHRONIZED)) return true;
10730	if (jj_scan_token(LPAREN)) return true;
10731	if (jj_3R_93()) return true;
10732	if (jj_scan_token(RPAREN)) return true;
10733	if (jj_3R_126()) return true;
10734	return false;
10735	}
10736
10737	private boolean jj_3R_219()
10738	{
10739	Token xsp;
10740	xsp = jj_scanpos;
10741	if (jj_3R_275()) {
10742	jj_scanpos = xsp;
10743	if (jj_3R_276()) {
10744	jj_scanpos = xsp;
10745	if (jj_3R_277()) {
10746	jj_scanpos = xsp;
10747	if (jj_3R_278()) {
10748	jj_scanpos = xsp;
10749	if (jj_3R_279()) {
10750	jj_scanpos = xsp;
10751	if (jj_3R_280()) {
10752	jj_scanpos = xsp;
10753	if (jj_3R_281()) {
10754	jj_scanpos = xsp;
10755	if (jj_3R_282()) return true;
10756	}
10757	}
10758	}
10759	}
10760	}
10761	}
10762	}
10763	return false;
10764	}
10765
10766	private boolean jj_3R_275()
10767	{
10768	if (jj_scan_token(INTEGER_LITERAL)) return true;
10769	return false;
10770	}
10771
10772	private boolean jj_3R_276()
10773	{
10774	if (jj_scan_token(LONG_LITERAL)) return true;
10775	return false;
10776	}
10777
10778	private boolean jj_3R_277()
10779	{
10780	if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
10781	return false;
10782	}
10783
10784	private boolean jj_3R_105()
10785	{
10786	Token xsp;
10787	xsp = jj_scanpos;
10788	if (jj_3R_169()) {
10789	jj_scanpos = xsp;
10790	if (jj_3R_170()) return true;
10791	}
10792	return false;
10793	}
10794
10795	private boolean jj_3R_278()
10796	{
10797	if (jj_scan_token(CHARACTER_LITERAL)) return true;
10798	return false;
10799	}
10800
10801	private boolean jj_3R_279()
10802	{
10803	if (jj_scan_token(STRING_LITERAL)) return true;
10804	return false;
10805	}
10806
10807	private boolean jj_3R_280()
10808	{
10809	if (jj_scan_token(TEXT_BLOCK_LITERAL)) return true;
10810	return false;
10811	}
10812
10813	private boolean jj_3R_169()
10814	{
10815	if (jj_scan_token(VOID)) return true;
10816	return false;
10817	}
10818
10819	private boolean jj_3R_281()
10820	{
10821	if (jj_3R_320()) return true;
10822	return false;
10823	}
10824
10825	private boolean jj_3R_170()
10826	{
10827	if (jj_3R_77()) return true;
10828	return false;
10829	}
10830
10831	private boolean jj_3R_282()
10832	{
10833	if (jj_3R_321()) return true;
10834	return false;
10835	}
10836
10837	private boolean jj_3R_108()
10838	{
10839	if (jj_scan_token(LBRACE)) return true;
10840	Token xsp;
10841	while (true) {
10842	xsp = jj_scanpos;
10843	if (jj_3R_171()) { jj_scanpos = xsp; break; }
10844	}
10845	if (jj_scan_token(RBRACE)) return true;
10846	return false;
10847	}
10848
10849	private boolean jj_3R_82()
10850	{
10851	if (jj_3R_76()) return true;
10852	Token xsp;
10853	while (true) {
10854	xsp = jj_scanpos;
10855	if (jj_3_23()) { jj_scanpos = xsp; break; }
10856	}
10857	return false;
10858	}
10859
10860	private boolean jj_3R_320()
10861	{
10862	Token xsp;
10863	xsp = jj_scanpos;
10864	if (jj_3R_350()) {
10865	jj_scanpos = xsp;
10866	if (jj_3R_351()) return true;
10867	}
10868	return false;
10869	}
10870
10871	private boolean jj_3R_171()
10872	{
10873	Token xsp;
10874	xsp = jj_scanpos;
10875	if (jj_3R_207()) {
10876	jj_scanpos = xsp;
10877	if (jj_scan_token(102)) return true;
10878	}
10879	return false;
10880	}
10881
10882	private boolean jj_3R_207()
10883	{
10884	if (jj_3R_261()) return true;
10885	return false;
10886	}
10887
10888	private boolean jj_3R_350()
10889	{
10890	if (jj_scan_token(TRUE)) return true;
10891	return false;
10892	}
10893
10894	private boolean jj_3_23()
10895	{
10896	if (jj_scan_token(DOT)) return true;
10897	if (jj_3R_76()) return true;
10898	return false;
10899	}
10900
10901	private boolean jj_3R_351()
10902	{
10903	if (jj_scan_token(FALSE)) return true;
10904	return false;
10905	}
10906
10907	private boolean jj_3R_321()
10908	{
10909	if (jj_scan_token(NULL)) return true;
10910	return false;
10911	}
10912
10913	private boolean jj_3R_91()
10914	{
10915	if (jj_3R_76()) return true;
10916	return false;
10917	}
10918
10919	private boolean jj_3R_305()
10920	{
10921	if (jj_scan_token(TRY)) return true;
10922	Token xsp;
10923	xsp = jj_scanpos;
10924	if (jj_3R_332()) jj_scanpos = xsp;
10925	if (jj_3R_126()) return true;
10926	xsp = jj_scanpos;
10927	if (jj_3R_431()) {
10928	jj_scanpos = xsp;
10929	if (jj_3R_432()) return true;
10930	}
10931	return false;
10932	}
10933
10934	private boolean jj_3R_332()
10935	{
10936	if (jj_3R_355()) return true;
10937	return false;
10938	}
10939
10940	private boolean jj_3R_431()
10941	{
10942	Token xsp;
10943	while (true) {
10944	xsp = jj_scanpos;
10945	if (jj_3R_445()) { jj_scanpos = xsp; break; }
10946	}
10947	xsp = jj_scanpos;
10948	if (jj_3R_446()) jj_scanpos = xsp;
10949	return false;
10950	}
10951
10952	private boolean jj_3R_445()
10953	{
10954	if (jj_scan_token(CATCH)) return true;
10955	if (jj_scan_token(LPAREN)) return true;
10956	if (jj_3R_112()) return true;
10957	if (jj_3R_182()) return true;
10958	Token xsp;
10959	while (true) {
10960	xsp = jj_scanpos;
10961	if (jj_3R_449()) { jj_scanpos = xsp; break; }
10962	}
10963	if (jj_3R_104()) return true;
10964	if (jj_scan_token(RPAREN)) return true;
10965	if (jj_3R_126()) return true;
10966	return false;
10967	}
10968
10969	private boolean jj_3R_187()
10970	{
10971	if (jj_scan_token(LPAREN)) return true;
10972	Token xsp;
10973	xsp = jj_scanpos;
10974	if (jj_3R_218()) jj_scanpos = xsp;
10975	if (jj_scan_token(RPAREN)) return true;
10976	return false;
10977	}
10978
10979	private boolean jj_3R_449()
10980	{
10981	if (jj_scan_token(BIT_OR)) return true;
10982	if (jj_3R_254()) return true;
10983	return false;
10984	}
10985
10986	private boolean jj_3R_218()
10987	{
10988	if (jj_3R_274()) return true;
10989	return false;
10990	}
10991
10992	private boolean jj_3R_261()
10993	{
10994	Token xsp;
10995	xsp = jj_scanpos;
10996	if (jj_3_9()) {
10997	jj_scanpos = xsp;
10998	if (jj_3R_313()) return true;
10999	}
11000	return false;
11001	}
11002
11003	private boolean jj_3_9()
11004	{
11005	if (jj_3R_79()) return true;
11006	return false;
11007	}
11008
11009	private boolean jj_3R_313()
11010	{
11011	if (jj_3R_112()) return true;
11012	Token xsp;
11013	xsp = jj_scanpos;
11014	if (jj_3R_339()) {
11015	jj_scanpos = xsp;
11016	if (jj_3R_340()) {
11017	jj_scanpos = xsp;
11018	if (jj_3R_341()) {
11019	jj_scanpos = xsp;
11020	if (jj_3R_342()) {
11021	jj_scanpos = xsp;
11022	if (jj_3R_343()) {
11023	jj_scanpos = xsp;
11024	if (jj_3R_344()) return true;
11025	}
11026	}
11027	}
11028	}
11029	}
11030	return false;
11031	}
11032
11033	private boolean jj_3R_432()
11034	{
11035	if (jj_scan_token(FINALLY)) return true;
11036	if (jj_3R_126()) return true;
11037	return false;
11038	}
11039
11040	private boolean jj_3R_446()
11041	{
11042	if (jj_scan_token(FINALLY)) return true;
11043	if (jj_3R_126()) return true;
11044	return false;
11045	}
11046
11047	private boolean jj_3R_76()
11048	{
11049	Token xsp;
11050	xsp = jj_scanpos;
11051	if (jj_scan_token(71)) {
11052	jj_scanpos = xsp;
11053	if (jj_scan_token(65)) {
11054	jj_scanpos = xsp;
11055	if (jj_scan_token(66)) {
11056	jj_scanpos = xsp;
11057	if (jj_scan_token(67)) {
11058	jj_scanpos = xsp;
11059	if (jj_scan_token(68)) {
11060	jj_scanpos = xsp;
11061	if (jj_scan_token(69)) {
11062	jj_scanpos = xsp;
11063	if (jj_scan_token(70)) {
11064	jj_scanpos = xsp;
11065	if (jj_scan_token(72)) {
11066	jj_scanpos = xsp;
11067	if (jj_scan_token(73)) {
11068	jj_scanpos = xsp;
11069	if (jj_scan_token(74)) {
11070	jj_scanpos = xsp;
11071	if (jj_scan_token(26)) {
11072	jj_scanpos = xsp;
11073	if (jj_scan_token(51)) {
11074	jj_scanpos = xsp;
11075	if (jj_scan_token(64)) {
11076	jj_scanpos = xsp;
11077	if (jj_scan_token(93)) return true;
11078	}
11079	}
11080	}
11081	}
11082	}
11083	}
11084	}
11085	}
11086	}
11087	}
11088	}
11089	}
11090	}
11091	return false;
11092	}
11093
11094	private boolean jj_3R_274()
11095	{
11096	if (jj_3R_93()) return true;
11097	Token xsp;
11098	while (true) {
11099	xsp = jj_scanpos;
11100	if (jj_3R_319()) { jj_scanpos = xsp; break; }
11101	}
11102	return false;
11103	}
11104
11105	private boolean jj_3R_339()
11106	{
11107	if (jj_3R_198()) return true;
11108	return false;
11109	}
11110
11111	private boolean jj_3R_340()
11112	{
11113	if (jj_3R_362()) return true;
11114	return false;
11115	}
11116
11117	private boolean jj_3R_319()
11118	{
11119	if (jj_scan_token(COMMA)) return true;
11120	if (jj_3R_93()) return true;
11121	return false;
11122	}
11123
11124	private boolean jj_3R_341()
11125	{
11126	if (jj_3R_363()) return true;
11127	return false;
11128	}
11129
11130	private boolean jj_3R_342()
11131	{
11132	if (jj_3R_364()) return true;
11133	return false;
11134	}
11135
11136	private boolean jj_3R_343()
11137	{
11138	if (jj_3R_365()) return true;
11139	return false;
11140	}
11141
11142	private boolean jj_3_5()
11143	{
11144	if (jj_scan_token(ENUM)) return true;
11145	return false;
11146	}
11147
11148	private boolean jj_3R_344()
11149	{
11150	if (jj_3R_366()) return true;
11151	return false;
11152	}
11153
11154	private boolean jj_3_6()
11155	{
11156	if (jj_scan_token(AT)) return true;
11157	if (jj_scan_token(INTERFACE)) return true;
11158	return false;
11159	}
11160
11161	private boolean jj_3_7()
11162	{
11163	Token xsp;
11164	xsp = jj_scanpos;
11165	if (jj_3R_75()) jj_scanpos = xsp;
11166	if (jj_3R_76()) return true;
11167	if (jj_scan_token(LPAREN)) return true;
11168	return false;
11169	}
11170
11171	private boolean jj_3R_75()
11172	{
11173	if (jj_3R_121()) return true;
11174	return false;
11175	}
11176
11177	private boolean jj_3_8()
11178	{
11179	if (jj_3R_77()) return true;
11180	if (jj_3R_76()) return true;
11181	Token xsp;
11182	while (true) {
11183	xsp = jj_scanpos;
11184	if (jj_3R_78()) { jj_scanpos = xsp; break; }
11185	}
11186	xsp = jj_scanpos;
11187	if (jj_scan_token(103)) {
11188	jj_scanpos = xsp;
11189	if (jj_scan_token(106)) {
11190	jj_scanpos = xsp;
11191	if (jj_scan_token(102)) return true;
11192	}
11193	}
11194	return false;
11195	}
11196
11197	private boolean jj_3R_355()
11198	{
11199	if (jj_scan_token(LPAREN)) return true;
11200	if (jj_3R_384()) return true;
11201	Token xsp;
11202	xsp = jj_scanpos;
11203	if (jj_3_48()) jj_scanpos = xsp;
11204	if (jj_scan_token(RPAREN)) return true;
11205	return false;
11206	}
11207
11208	private boolean jj_3_48()
11209	{
11210	if (jj_scan_token(SEMICOLON)) return true;
11211	return false;
11212	}
11213
11214	private boolean jj_3R_93()
11215	{
11216	if (jj_3R_152()) return true;
11217	Token xsp;
11218	xsp = jj_scanpos;
11219	if (jj_3R_208()) jj_scanpos = xsp;
11220	return false;
11221	}
11222
11223	private boolean jj_3R_365()
11224	{
11225	if (jj_3R_77()) return true;
11226	if (jj_3R_116()) return true;
11227	Token xsp;
11228	while (true) {
11229	xsp = jj_scanpos;
11230	if (jj_3R_415()) { jj_scanpos = xsp; break; }
11231	}
11232	if (jj_scan_token(SEMICOLON)) return true;
11233	return false;
11234	}
11235
11236	private boolean jj_3R_208()
11237	{
11238	Token xsp;
11239	xsp = jj_scanpos;
11240	if (jj_3_24()) {
11241	jj_scanpos = xsp;
11242	if (jj_3R_263()) {
11243	jj_scanpos = xsp;
11244	if (jj_3R_264()) return true;
11245	}
11246	}
11247	return false;
11248	}
11249
11250	private boolean jj_3R_415()
11251	{
11252	if (jj_scan_token(COMMA)) return true;
11253	if (jj_3R_116()) return true;
11254	return false;
11255	}
11256
11257	private boolean jj_3R_78()
11258	{
11259	if (jj_3R_124()) return true;
11260	return false;
11261	}
11262
11263	private boolean jj_3_24()
11264	{
11265	if (jj_3R_92()) return true;
11266	if (jj_3R_93()) return true;
11267	return false;
11268	}
11269
11270	private boolean jj_3R_263()
11271	{
11272	if (jj_scan_token(ARROW)) return true;
11273	if (jj_3R_336()) return true;
11274	return false;
11275	}
11276
11277	private boolean jj_3R_226()
11278	{
11279	if (jj_scan_token(NEW)) return true;
11280	Token xsp;
11281	xsp = jj_scanpos;
11282	if (jj_3R_289()) jj_scanpos = xsp;
11283	if (jj_3R_89()) return true;
11284	xsp = jj_scanpos;
11285	if (jj_3R_290()) {
11286	jj_scanpos = xsp;
11287	if (jj_3R_291()) return true;
11288	}
11289	return false;
11290	}
11291
11292	private boolean jj_3R_289()
11293	{
11294	if (jj_3R_90()) return true;
11295	return false;
11296	}
11297
11298	private boolean jj_3R_264()
11299	{
11300	if (jj_scan_token(DOUBLECOLON)) return true;
11301	Token xsp;
11302	xsp = jj_scanpos;
11303	if (jj_3R_337()) jj_scanpos = xsp;
11304	xsp = jj_scanpos;
11305	if (jj_3R_338()) {
11306	jj_scanpos = xsp;
11307	if (jj_scan_token(42)) return true;
11308	}
11309	return false;
11310	}
11311
11312	private boolean jj_3R_384()
11313	{
11314	if (jj_3R_115()) return true;
11315	Token xsp;
11316	while (true) {
11317	xsp = jj_scanpos;
11318	if (jj_3_49()) { jj_scanpos = xsp; break; }
11319	}
11320	return false;
11321	}
11322
11323	private boolean jj_3R_290()
11324	{
11325	if (jj_3R_100()) return true;
11326	if (jj_3R_324()) return true;
11327	return false;
11328	}
11329
11330	private boolean jj_3R_337()
11331	{
11332	if (jj_3R_90()) return true;
11333	return false;
11334	}
11335
11336	private boolean jj_3R_116()
11337	{
11338	if (jj_3R_104()) return true;
11339	Token xsp;
11340	xsp = jj_scanpos;
11341	if (jj_3R_176()) jj_scanpos = xsp;
11342	return false;
11343	}
11344
11345	private boolean jj_3R_338()
11346	{
11347	if (jj_3R_76()) return true;
11348	return false;
11349	}
11350
11351	private boolean jj_3R_291()
11352	{
11353	if (jj_3R_137()) return true;
11354	Token xsp;
11355	xsp = jj_scanpos;
11356	if (jj_3R_325()) {
11357	jj_scanpos = xsp;
11358	if (jj_3R_326()) return true;
11359	}
11360	return false;
11361	}
11362
11363	private boolean jj_3R_176()
11364	{
11365	if (jj_scan_token(ASSIGN)) return true;
11366	if (jj_3R_80()) return true;
11367	return false;
11368	}
11369
11370	private boolean jj_3R_325()
11371	{
11372	if (jj_3R_324()) return true;
11373	return false;
11374	}
11375
11376	private boolean jj_3R_326()
11377	{
11378	if (jj_3R_187()) return true;
11379	Token xsp;
11380	xsp = jj_scanpos;
11381	if (jj_3_39()) jj_scanpos = xsp;
11382	return false;
11383	}
11384
11385	private boolean jj_3_39()
11386	{
11387	if (jj_3R_108()) return true;
11388	return false;
11389	}
11390
11391	private boolean jj_3R_92()
11392	{
11393	Token xsp;
11394	xsp = jj_scanpos;
11395	if (jj_3R_140()) {
11396	jj_scanpos = xsp;
11397	if (jj_3R_141()) {
11398	jj_scanpos = xsp;
11399	if (jj_3R_142()) {
11400	jj_scanpos = xsp;
11401	if (jj_3R_143()) {
11402	jj_scanpos = xsp;
11403	if (jj_3R_144()) {
11404	jj_scanpos = xsp;
11405	if (jj_3R_145()) {
11406	jj_scanpos = xsp;
11407	if (jj_3R_146()) {
11408	jj_scanpos = xsp;
11409	if (jj_3R_147()) {
11410	jj_scanpos = xsp;
11411	if (jj_3R_148()) {
11412	jj_scanpos = xsp;
11413	if (jj_3R_149()) {
11414	jj_scanpos = xsp;
11415	if (jj_3R_150()) {
11416	jj_scanpos = xsp;
11417	if (jj_3R_151()) return true;
11418	}
11419	}
11420	}
11421	}
11422	}
11423	}
11424	}
11425	}
11426	}
11427	}
11428	}
11429	return false;
11430	}
11431
11432	private boolean jj_3R_140()
11433	{
11434	if (jj_scan_token(ASSIGN)) return true;
11435	return false;
11436	}
11437
11438	private boolean jj_3R_141()
11439	{
11440	if (jj_scan_token(STARASSIGN)) return true;
11441	return false;
11442	}
11443
11444	private boolean jj_3R_115()
11445	{
11446	Token xsp;
11447	xsp = jj_scanpos;
11448	if (jj_3R_174()) {
11449	jj_scanpos = xsp;
11450	if (jj_3R_175()) return true;
11451	}
11452	return false;
11453	}
11454
11455	private boolean jj_3R_142()
11456	{
11457	if (jj_scan_token(SLASHASSIGN)) return true;
11458	return false;
11459	}
11460
11461	private boolean jj_3R_143()
11462	{
11463	if (jj_scan_token(REMASSIGN)) return true;
11464	return false;
11465	}
11466
11467	private boolean jj_3R_144()
11468	{
11469	if (jj_scan_token(PLUSASSIGN)) return true;
11470	return false;
11471	}
11472
11473	private boolean jj_3R_145()
11474	{
11475	if (jj_scan_token(MINUSASSIGN)) return true;
11476	return false;
11477	}
11478
11479	private boolean jj_3R_146()
11480	{
11481	if (jj_scan_token(LSHIFTASSIGN)) return true;
11482	return false;
11483	}
11484
11485	private boolean jj_3R_147()
11486	{
11487	if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
11488	return false;
11489	}
11490
11491	private boolean jj_3R_174()
11492	{
11493	if (jj_3R_113()) return true;
11494	return false;
11495	}
11496
11497	private boolean jj_3R_148()
11498	{
11499	if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
11500	return false;
11501	}
11502
11503	private boolean jj_3R_149()
11504	{
11505	if (jj_scan_token(ANDASSIGN)) return true;
11506	return false;
11507	}
11508
11509	private boolean jj_3R_150()
11510	{
11511	if (jj_scan_token(XORASSIGN)) return true;
11512	return false;
11513	}
11514
11515	private boolean jj_3R_151()
11516	{
11517	if (jj_scan_token(ORASSIGN)) return true;
11518	return false;
11519	}
11520
11521	private boolean jj_3_50()
11522	{
11523	if (jj_3R_112()) return true;
11524	if (jj_3R_77()) return true;
11525	if (jj_3R_116()) return true;
11526	return false;
11527	}
11528
11529	private boolean jj_3R_104()
11530	{
11531	if (jj_3R_91()) return true;
11532	Token xsp;
11533	while (true) {
11534	xsp = jj_scanpos;
11535	if (jj_3R_168()) { jj_scanpos = xsp; break; }
11536	}
11537	return false;
11538	}
11539
11540	private boolean jj_3R_175()
11541	{
11542	if (jj_3R_213()) return true;
11543	return false;
11544	}
11545
11546	private boolean jj_3_49()
11547	{
11548	if (jj_scan_token(SEMICOLON)) return true;
11549	if (jj_3R_115()) return true;
11550	return false;
11551	}
11552
11553	private boolean jj_3R_168()
11554	{
11555	if (jj_3R_124()) return true;
11556	return false;
11557	}
11558
11559	private boolean jj_3R_324()
11560	{
11561	Token xsp;
11562	if (jj_3_40()) return true;
11563	while (true) {
11564	xsp = jj_scanpos;
11565	if (jj_3_40()) { jj_scanpos = xsp; break; }
11566	}
11567	xsp = jj_scanpos;
11568	if (jj_3R_352()) jj_scanpos = xsp;
11569	return false;
11570	}
11571
11572	private boolean jj_3R_96()
11573	{
11574	jj_lookingAhead = true;
11575	jj_semLA = getToken(1).kind == GT && getToken(1).realKind == RUNSIGNEDSHIFT;
11576	jj_lookingAhead = false;
11577	if (!jj_semLA \|\| jj_3R_154()) return true;
11578	if (jj_scan_token(GT)) return true;
11579	if (jj_scan_token(GT)) return true;
11580	if (jj_scan_token(GT)) return true;
11581	return false;
11582	}
11583
11584	private boolean jj_3_40()
11585	{
11586	if (jj_3R_89()) return true;
11587	if (jj_scan_token(LBRACKET)) return true;
11588	Token xsp;
11589	xsp = jj_scanpos;
11590	if (jj_3R_109()) jj_scanpos = xsp;
11591	if (jj_scan_token(RBRACKET)) return true;
11592	return false;
11593	}
11594
11595	private boolean jj_3R_352()
11596	{
11597	if (jj_3R_184()) return true;
11598	return false;
11599	}
11600
11601	private boolean jj_3R_109()
11602	{
11603	if (jj_3R_93()) return true;
11604	return false;
11605	}
11606
11607	private boolean jj_3R_152()
11608	{
11609	if (jj_3R_201()) return true;
11610	Token xsp;
11611	xsp = jj_scanpos;
11612	if (jj_3R_262()) jj_scanpos = xsp;
11613	return false;
11614	}
11615
11616	private boolean jj_3R_95()
11617	{
11618	jj_lookingAhead = true;
11619	jj_semLA = getToken(1).kind == GT && getToken(1).realKind == RSIGNEDSHIFT;
11620	jj_lookingAhead = false;
11621	if (!jj_semLA \|\| jj_3R_153()) return true;
11622	if (jj_scan_token(GT)) return true;
11623	if (jj_scan_token(GT)) return true;
11624	return false;
11625	}
11626
11627	private boolean jj_3R_154()
11628	{
11629	return false;
11630	}
11631
11632	private boolean jj_3R_262()
11633	{
11634	if (jj_scan_token(HOOK)) return true;
11635	if (jj_3R_93()) return true;
11636	if (jj_scan_token(COLON)) return true;
11637	if (jj_3R_152()) return true;
11638	return false;
11639	}
11640
11641	private boolean jj_3R_80()
11642	{
11643	Token xsp;
11644	xsp = jj_scanpos;
11645	if (jj_3R_127()) {
11646	jj_scanpos = xsp;
11647	if (jj_3R_128()) return true;
11648	}
11649	return false;
11650	}
11651
11652	private boolean jj_3R_153()
11653	{
11654	return false;
11655	}
11656
11657	private boolean jj_3R_127()
11658	{
11659	if (jj_3R_184()) return true;
11660	return false;
11661	}
11662
11663	private boolean jj_3R_128()
11664	{
11665	if (jj_3R_93()) return true;
11666	return false;
11667	}
11668
11669	private boolean jj_3R_89()
11670	{
11671	Token xsp;
11672	while (true) {
11673	xsp = jj_scanpos;
11674	if (jj_3R_138()) { jj_scanpos = xsp; break; }
11675	}
11676	return false;
11677	}
11678
11679	private boolean jj_3R_138()
11680	{
11681	if (jj_3R_119()) return true;
11682	return false;
11683	}
11684
11685	private boolean jj_3R_201()
11686	{
11687	if (jj_3R_253()) return true;
11688	Token xsp;
11689	while (true) {
11690	xsp = jj_scanpos;
11691	if (jj_3R_314()) { jj_scanpos = xsp; break; }
11692	}
11693	return false;
11694	}
11695
11696	private boolean jj_3R_314()
11697	{
11698	if (jj_scan_token(SC_OR)) return true;
11699	if (jj_3R_253()) return true;
11700	return false;
11701	}
11702
11703	private boolean jj_3_51()
11704	{
11705	if (jj_scan_token(AT)) return true;
11706	return false;
11707	}
11708
11709	private boolean jj_3R_184()
11710	{
11711	if (jj_scan_token(LBRACE)) return true;
11712	Token xsp;
11713	xsp = jj_scanpos;
11714	if (jj_3R_346()) jj_scanpos = xsp;
11715	xsp = jj_scanpos;
11716	if (jj_scan_token(103)) jj_scanpos = xsp;
11717	if (jj_scan_token(RBRACE)) return true;
11718	return false;
11719	}
11720
11721	private boolean jj_3R_199()
11722	{
11723	Token xsp;
11724	xsp = jj_scanpos;
11725	if (jj_3_41()) {
11726	jj_scanpos = xsp;
11727	if (jj_3R_233()) {
11728	jj_scanpos = xsp;
11729	if (jj_3_42()) {
11730	jj_scanpos = xsp;
11731	if (jj_3R_234()) {
11732	jj_scanpos = xsp;
11733	if (jj_3R_235()) {
11734	jj_scanpos = xsp;
11735	if (jj_3R_236()) {
11736	jj_scanpos = xsp;
11737	if (jj_3R_237()) {
11738	jj_scanpos = xsp;
11739	if (jj_3R_238()) {
11740	jj_scanpos = xsp;
11741	if (jj_3R_239()) {
11742	jj_scanpos = xsp;
11743	if (jj_3R_240()) {
11744	jj_scanpos = xsp;
11745	if (jj_3R_241()) {
11746	jj_scanpos = xsp;
11747	if (jj_3R_242()) {
11748	jj_scanpos = xsp;
11749	if (jj_3R_243()) {
11750	jj_scanpos = xsp;
11751	if (jj_3R_244()) {
11752	jj_scanpos = xsp;
11753	if (jj_3R_245()) {
11754	jj_scanpos = xsp;
11755	if (jj_3R_246()) {
11756	jj_scanpos = xsp;
11757	if (jj_3R_247()) return true;
11758	}
11759	}
11760	}
11761	}
11762	}
11763	}
11764	}
11765	}
11766	}
11767	}
11768	}
11769	}
11770	}
11771	}
11772	}
11773	}
11774	return false;
11775	}
11776
11777	private boolean jj_3R_346()
11778	{
11779	if (jj_3R_80()) return true;
11780	Token xsp;
11781	while (true) {
11782	xsp = jj_scanpos;
11783	if (jj_3_10()) { jj_scanpos = xsp; break; }
11784	}
11785	return false;
11786	}
11787
11788	private boolean jj_3_10()
11789	{
11790	if (jj_scan_token(COMMA)) return true;
11791	if (jj_3R_80()) return true;
11792	return false;
11793	}
11794
11795	private boolean jj_3_41()
11796	{
11797	if (jj_3R_110()) return true;
11798	return false;
11799	}
11800
11801	private boolean jj_3R_233()
11802	{
11803	if (jj_3R_292()) return true;
11804	return false;
11805	}
11806
11807	private boolean jj_3_42()
11808	{
11809	if (jj_3R_111()) return true;
11810	return false;
11811	}
11812
11813	private boolean jj_3R_234()
11814	{
11815	if (jj_3R_126()) return true;
11816	return false;
11817	}
11818
11819	private boolean jj_3R_235()
11820	{
11821	if (jj_3R_293()) return true;
11822	return false;
11823	}
11824
11825	private boolean jj_3R_236()
11826	{
11827	if (jj_3R_294()) return true;
11828	return false;
11829	}
11830
11831	private boolean jj_3R_237()
11832	{
11833	if (jj_3R_295()) return true;
11834	return false;
11835	}
11836
11837	private boolean jj_3R_238()
11838	{
11839	if (jj_3R_296()) return true;
11840	return false;
11841	}
11842
11843	private boolean jj_3R_239()
11844	{
11845	if (jj_3R_297()) return true;
11846	return false;
11847	}
11848
11849	private boolean jj_3R_240()
11850	{
11851	if (jj_3R_298()) return true;
11852	return false;
11853	}
11854
11855	private boolean jj_3R_241()
11856	{
11857	if (jj_3R_299()) return true;
11858	return false;
11859	}
11860
11861	private boolean jj_3R_242()
11862	{
11863	if (jj_3R_300()) return true;
11864	return false;
11865	}
11866
11867	private boolean jj_3R_243()
11868	{
11869	if (jj_3R_301()) return true;
11870	return false;
11871	}
11872
11873	private boolean jj_3R_244()
11874	{
11875	if (jj_3R_302()) return true;
11876	return false;
11877	}
11878
11879	private boolean jj_3R_245()
11880	{
11881	if (jj_3R_303()) return true;
11882	return false;
11883	}
11884
11885	private boolean jj_3R_253()
11886	{
11887	if (jj_3R_308()) return true;
11888	Token xsp;
11889	while (true) {
11890	xsp = jj_scanpos;
11891	if (jj_3R_345()) { jj_scanpos = xsp; break; }
11892	}
11893	return false;
11894	}
11895
11896	private boolean jj_3R_246()
11897	{
11898	if (jj_3R_304()) return true;
11899	return false;
11900	}
11901
11902	private boolean jj_3R_247()
11903	{
11904	if (jj_3R_305()) return true;
11905	return false;
11906	}
11907
11908	private boolean jj_3R_345()
11909	{
11910	if (jj_scan_token(SC_AND)) return true;
11911	if (jj_3R_308()) return true;
11912	return false;
11913	}
11914
11915	private boolean jj_3R_366()
11916	{
11917	Token xsp;
11918	xsp = jj_scanpos;
11919	if (jj_3R_381()) jj_scanpos = xsp;
11920	if (jj_3R_89()) return true;
11921	if (jj_3R_105()) return true;
11922	if (jj_3R_91()) return true;
11923	if (jj_3R_412()) return true;
11924	while (true) {
11925	xsp = jj_scanpos;
11926	if (jj_3R_416()) { jj_scanpos = xsp; break; }
11927	}
11928	xsp = jj_scanpos;
11929	if (jj_3R_417()) jj_scanpos = xsp;
11930	xsp = jj_scanpos;
11931	if (jj_3R_418()) {
11932	jj_scanpos = xsp;
11933	if (jj_scan_token(102)) return true;
11934	}
11935	return false;
11936	}
11937
11938	private boolean jj_3R_381()
11939	{
11940	if (jj_3R_121()) return true;
11941	return false;
11942	}
11943
11944	private boolean jj_3R_292()
11945	{
11946	if (jj_scan_token(ASSERT)) return true;
11947	if (jj_3R_93()) return true;
11948	Token xsp;
11949	xsp = jj_scanpos;
11950	if (jj_3R_347()) jj_scanpos = xsp;
11951	if (jj_scan_token(SEMICOLON)) return true;
11952	return false;
11953	}
11954
11955	private boolean jj_3R_119()
11956	{
11957	if (jj_scan_token(AT)) return true;
11958	if (jj_3R_82()) return true;
11959	Token xsp;
11960	xsp = jj_scanpos;
11961	if (jj_3R_248()) {
11962	jj_scanpos = xsp;
11963	if (jj_3R_249()) {
11964	jj_scanpos = xsp;
11965	if (jj_3R_250()) return true;
11966	}
11967	}
11968	return false;
11969	}
11970
11971	private boolean jj_3R_347()
11972	{
11973	if (jj_scan_token(COLON)) return true;
11974	if (jj_3R_93()) return true;
11975	return false;
11976	}
11977
11978	private boolean jj_3R_416()
11979	{
11980	if (jj_3R_124()) return true;
11981	return false;
11982	}
11983
11984	private boolean jj_3R_417()
11985	{
11986	if (jj_scan_token(THROWS)) return true;
11987	if (jj_3R_254()) return true;
11988	Token xsp;
11989	while (true) {
11990	xsp = jj_scanpos;
11991	if (jj_3R_426()) { jj_scanpos = xsp; break; }
11992	}
11993	return false;
11994	}
11995
11996	private boolean jj_3R_248()
11997	{
11998	if (jj_scan_token(LPAREN)) return true;
11999	Token xsp;
12000	xsp = jj_scanpos;
12001	if (jj_3R_306()) jj_scanpos = xsp;
12002	if (jj_scan_token(RPAREN)) return true;
12003	return false;
12004	}
12005
12006	private boolean jj_3R_426()
12007	{
12008	if (jj_scan_token(COMMA)) return true;
12009	if (jj_3R_254()) return true;
12010	return false;
12011	}
12012
12013	private boolean jj_3R_306()
12014	{
12015	if (jj_3R_333()) return true;
12016	return false;
12017	}
12018
12019	private boolean jj_3R_418()
12020	{
12021	if (jj_3R_126()) return true;
12022	return false;
12023	}
12024
12025	private boolean jj_3R_249()
12026	{
12027	if (jj_scan_token(LPAREN)) return true;
12028	if (jj_3R_118()) return true;
12029	if (jj_scan_token(RPAREN)) return true;
12030	return false;
12031	}
12032
12033	private boolean jj_3R_308()
12034	{
12035	if (jj_3R_334()) return true;
12036	Token xsp;
12037	while (true) {
12038	xsp = jj_scanpos;
12039	if (jj_3R_367()) { jj_scanpos = xsp; break; }
12040	}
12041	return false;
12042	}
12043
12044	private boolean jj_3_52()
12045	{
12046	if (jj_scan_token(LPAREN)) return true;
12047	Token xsp;
12048	xsp = jj_scanpos;
12049	if (jj_3R_117()) {
12050	jj_scanpos = xsp;
12051	if (jj_scan_token(97)) return true;
12052	}
12053	return false;
12054	}
12055
12056	private boolean jj_3R_250()
12057	{
12058	return false;
12059	}
12060
12061	private boolean jj_3R_110()
12062	{
12063	if (jj_3R_91()) return true;
12064	if (jj_scan_token(COLON)) return true;
12065	if (jj_3R_199()) return true;
12066	return false;
12067	}
12068
12069	private boolean jj_3R_367()
12070	{
12071	if (jj_scan_token(BIT_OR)) return true;
12072	if (jj_3R_334()) return true;
12073	return false;
12074	}
12075
12076	private boolean jj_3R_117()
12077	{
12078	if (jj_3R_76()) return true;
12079	if (jj_scan_token(ASSIGN)) return true;
12080	return false;
12081	}
12082
12083	private boolean jj_3_53()
12084	{
12085	if (jj_scan_token(LPAREN)) return true;
12086	return false;
12087	}
12088
12089	private boolean jj_3R_254()
12090	{
12091	if (jj_3R_89()) return true;
12092	if (jj_3R_182()) return true;
12093	return false;
12094	}
12095
12096	private boolean jj_3R_106()
12097	{
12098	if (jj_3R_89()) return true;
12099	if (jj_3R_77()) return true;
12100	return false;
12101	}
12102
12103	private boolean jj_3R_333()
12104	{
12105	if (jj_3R_356()) return true;
12106	Token xsp;
12107	while (true) {
12108	xsp = jj_scanpos;
12109	if (jj_3R_357()) { jj_scanpos = xsp; break; }
12110	}
12111	return false;
12112	}
12113
12114	private boolean jj_3R_357()
12115	{
12116	if (jj_scan_token(COMMA)) return true;
12117	if (jj_3R_356()) return true;
12118	return false;
12119	}
12120
12121	private boolean jj_3R_126()
12122	{
12123	if (jj_scan_token(LBRACE)) return true;
12124	if (jj_3R_183()) return true;
12125	if (jj_scan_token(RBRACE)) return true;
12126	return false;
12127	}
12128
12129	private boolean jj_3R_334()
12130	{
12131	if (jj_3R_358()) return true;
12132	Token xsp;
12133	while (true) {
12134	xsp = jj_scanpos;
12135	if (jj_3R_382()) { jj_scanpos = xsp; break; }
12136	}
12137	return false;
12138	}
12139
12140	private boolean jj_3R_382()
12141	{
12142	if (jj_scan_token(XOR)) return true;
12143	if (jj_3R_358()) return true;
12144	return false;
12145	}
12146
12147	private boolean jj_3R_356()
12148	{
12149	if (jj_3R_91()) return true;
12150	if (jj_scan_token(ASSIGN)) return true;
12151	if (jj_3R_118()) return true;
12152	return false;
12153	}
12154
12155	private boolean jj_3R_412()
12156	{
12157	if (jj_scan_token(LPAREN)) return true;
12158	Token xsp;
12159	xsp = jj_scanpos;
12160	if (jj_3R_424()) jj_scanpos = xsp;
12161	if (jj_scan_token(RPAREN)) return true;
12162	return false;
12163	}
12164
12165	private boolean jj_3R_424()
12166	{
12167	Token xsp;
12168	xsp = jj_scanpos;
12169	if (jj_3R_440()) {
12170	jj_scanpos = xsp;
12171	if (jj_3R_441()) return true;
12172	}
12173	while (true) {
12174	xsp = jj_scanpos;
12175	if (jj_3R_442()) { jj_scanpos = xsp; break; }
12176	}
12177	return false;
12178	}
12179
12180	private boolean jj_3R_358()
12181	{
12182	if (jj_3R_375()) return true;
12183	Token xsp;
12184	while (true) {
12185	xsp = jj_scanpos;
12186	if (jj_3R_390()) { jj_scanpos = xsp; break; }
12187	}
12188	return false;
12189	}
12190
12191	private boolean jj_3R_440()
12192	{
12193	if (jj_3R_81()) return true;
12194	return false;
12195	}
12196
12197	private boolean jj_3R_441()
12198	{
12199	if (jj_3R_103()) return true;
12200	return false;
12201	}
12202
12203	private boolean jj_3R_442()
12204	{
12205	if (jj_scan_token(COMMA)) return true;
12206	if (jj_3R_103()) return true;
12207	return false;
12208	}
12209
12210	private boolean jj_3R_390()
12211	{
12212	if (jj_scan_token(BIT_AND)) return true;
12213	if (jj_3R_375()) return true;
12214	return false;
12215	}
12216
12217	private boolean jj_3_11()
12218	{
12219	if (jj_3R_81()) return true;
12220	return false;
12221	}
12222
12223	private boolean jj_3R_118()
12224	{
12225	Token xsp;
12226	xsp = jj_scanpos;
12227	if (jj_3R_177()) {
12228	jj_scanpos = xsp;
12229	if (jj_3R_178()) {
12230	jj_scanpos = xsp;
12231	if (jj_3R_179()) return true;
12232	}
12233	}
12234	return false;
12235	}
12236
12237	private boolean jj_3R_86()
12238	{
12239	Token xsp;
12240	xsp = jj_scanpos;
12241	if (jj_3R_134()) {
12242	jj_scanpos = xsp;
12243	if (jj_3R_135()) {
12244	jj_scanpos = xsp;
12245	if (jj_3R_136()) return true;
12246	}
12247	}
12248	return false;
12249	}
12250
12251	private boolean jj_3R_177()
12252	{
12253	if (jj_3R_119()) return true;
12254	return false;
12255	}
12256
12257	private boolean jj_3R_178()
12258	{
12259	if (jj_3R_214()) return true;
12260	return false;
12261	}
12262
12263	private boolean jj_3R_179()
12264	{
12265	if (jj_3R_152()) return true;
12266	return false;
12267	}
12268
12269	private boolean jj_3_54()
12270	{
12271	if (jj_scan_token(AT)) return true;
12272	return false;
12273	}
12274
12275	private boolean jj_3R_134()
12276	{
12277	if (jj_3R_112()) return true;
12278	if (jj_3R_198()) return true;
12279	return false;
12280	}
12281
12282	private boolean jj_3R_135()
12283	{
12284	if (jj_3R_113()) return true;
12285	if (jj_scan_token(SEMICOLON)) return true;
12286	return false;
12287	}
12288
12289	private boolean jj_3R_136()
12290	{
12291	if (jj_3R_199()) return true;
12292	return false;
12293	}
12294
12295	private boolean jj_3_43()
12296	{
12297	if (jj_3R_112()) return true;
12298	Token xsp;
12299	xsp = jj_scanpos;
12300	if (jj_scan_token(19)) {
12301	jj_scanpos = xsp;
12302	if (jj_scan_token(39)) return true;
12303	}
12304	return false;
12305	}
12306
12307	private boolean jj_3R_375()
12308	{
12309	if (jj_3R_385()) return true;
12310	Token xsp;
12311	while (true) {
12312	xsp = jj_scanpos;
12313	if (jj_3R_394()) { jj_scanpos = xsp; break; }
12314	}
12315	return false;
12316	}
12317
12318	private boolean jj_3R_214()
12319	{
12320	if (jj_scan_token(LBRACE)) return true;
12321	Token xsp;
12322	xsp = jj_scanpos;
12323	if (jj_3R_374()) jj_scanpos = xsp;
12324	xsp = jj_scanpos;
12325	if (jj_scan_token(103)) jj_scanpos = xsp;
12326	if (jj_scan_token(RBRACE)) return true;
12327	return false;
12328	}
12329
12330	private boolean jj_3_44()
12331	{
12332	if (jj_3R_113()) return true;
12333	return false;
12334	}
12335
12336	private boolean jj_3R_287()
12337	{
12338	if (jj_3R_103()) return true;
12339	Token xsp;
12340	while (true) {
12341	xsp = jj_scanpos;
12342	if (jj_3R_322()) { jj_scanpos = xsp; break; }
12343	}
12344	return false;
12345	}
12346
12347	private boolean jj_3R_322()
12348	{
12349	if (jj_scan_token(COMMA)) return true;
12350	if (jj_3R_103()) return true;
12351	return false;
12352	}
12353
12354	private boolean jj_3R_394()
12355	{
12356	Token xsp;
12357	xsp = jj_scanpos;
12358	if (jj_3R_398()) {
12359	jj_scanpos = xsp;
12360	if (jj_3R_399()) return true;
12361	}
12362	if (jj_3R_385()) return true;
12363	return false;
12364	}
12365
12366	private boolean jj_3R_113()
12367	{
12368	if (jj_3R_112()) return true;
12369	if (jj_3R_77()) return true;
12370	if (jj_3R_116()) return true;
12371	Token xsp;
12372	while (true) {
12373	xsp = jj_scanpos;
12374	if (jj_3R_172()) { jj_scanpos = xsp; break; }
12375	}
12376	return false;
12377	}
12378
12379	private boolean jj_3R_374()
12380	{
12381	if (jj_3R_118()) return true;
12382	Token xsp;
12383	while (true) {
12384	xsp = jj_scanpos;
12385	if (jj_3_55()) { jj_scanpos = xsp; break; }
12386	}
12387	return false;
12388	}
12389
12390	private boolean jj_3R_398()
12391	{
12392	if (jj_scan_token(EQ)) return true;
12393	return false;
12394	}
12395
12396	private boolean jj_3R_399()
12397	{
12398	if (jj_scan_token(NE)) return true;
12399	return false;
12400	}
12401
12402	private boolean jj_3_55()
12403	{
12404	if (jj_scan_token(COMMA)) return true;
12405	if (jj_3R_118()) return true;
12406	return false;
12407	}
12408
12409	private boolean jj_3R_172()
12410	{
12411	if (jj_scan_token(COMMA)) return true;
12412	if (jj_3R_116()) return true;
12413	return false;
12414	}
12415
12416	/** Generated Token Manager. */
12417	public GeneratedJavaParserTokenManager token_source;
12418	SimpleCharStream jj_input_stream;
12419	/** Current token. */
12420	public Token token;
12421	/** Next token. */
12422	public Token jj_nt;
12423	private int jj_ntk;
12424	private Token jj_scanpos, jj_lastpos;
12425	private int jj_la;
12426	/** Whether we are looking ahead. */
12427	private boolean jj_lookingAhead = false;
12428	private boolean jj_semLA;
12429	private int jj_gen;
12430	final private int[] jj_la1 = new int[170];
12431	static private int[] jj_la1_0;
12432	static private int[] jj_la1_1;
12433	static private int[] jj_la1_2;
12434	static private int[] jj_la1_3;
12435	static private int[] jj_la1_4;
12436	static {
12437	jj_la1_init_0();
12438	jj_la1_init_1();
12439	jj_la1_init_2();
12440	jj_la1_init_3();
12441	jj_la1_init_4();
12442	}
12443	private static void jj_la1_init_0() {
12444	jj_la1_0 = new int[] {0x24480800,0x4080000,0x24480800,0x1,0x0,0x0,0x20400800,0x80000,0x0,0x8000000,0x0,0x0,0x0,0x0,0x4000000,0x0,0xa54ca800,0xa54ca800,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0xa54ca800,0xa54ca800,0x80000,0x8504a000,0xa54ca800,0x0,0x0,0x0,0x9504a000,0x9504a000,0x0,0x0,0x0,0x0,0x0,0x0,0xa544a800,0x0,0xa544a800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x0,0x8104a000,0x8504a000,0x8504a000,0x0,0x8504a000,0x8504a000,0x8000000,0x8000000,0x8104a000,0x8504a000,0x4000000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x0,0x0,0x9504a000,0x0,0x0,0x8504a000,0x0,0x0,0x0,0x4000000,0x0,0x0,0x9504a000,0x0,0x4000000,0x0,0x10000000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x9504a000,0x0,0x0,0x0,0x8504a000,0x9504a000,0x0,0x1000,0x95a4e000,0x0,0x95a4f000,0x0,0x9504a000,0x0,0x0,0x9504a000,0x410000,0x410000,0x0,0x410000,0x9504a000,0x0,0x2000000,0xb544a800,0x9504a000,0x9504a000,0xb544a800,0x9504a000,0x0,0x4000000,0x4000000,0x9504a000,0x0,0x20000,0x0,0x40000000,0x9504a000,0x4000000,0x0,0x9504a000,0x9504a000,0x0,0xa54ca800,0xa54ca800,0x80000,0x8504a000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9504a000,0x4080000,};
12445	}
12446	private static void jj_la1_init_1() {
12447	jj_la1_1 = new int[] {0x444ce290,0x80,0x444ce290,0x0,0x40000,0x0,0x444ce200,0x80,0x0,0x0,0x8,0x0,0x0,0x8,0x80000,0x0,0x644ee3c0,0x644ee3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x644ee3c0,0x644ee3c0,0x80,0x200a0140,0x644ee3c0,0x0,0x0,0x0,0x28ba0d40,0x28ba0d40,0x0,0x0,0x0,0x0,0x2000000,0x0,0x444ee340,0x0,0x444ee340,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x289a0d40,0x40000,0x20140,0xa0140,0xa0140,0x0,0xa0140,0xa0140,0x100000,0x100000,0x20140,0x200a0140,0x80000,0x0,0x80400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28ba0d40,0x0,0x0,0x28ba0d40,0x0,0x0,0xa0140,0x0,0x0,0x0,0x80400,0x0,0x0,0x28ba0d40,0x0,0x80400,0x0,0x8900c00,0x80000,0x0,0x0,0x0,0x800400,0x0,0x8000800,0x8000000,0x28ba0d40,0x0,0x0,0x0,0xa0140,0x28ba0d40,0x0,0x0,0xb9fb0d45,0x0,0xb9fb0d45,0x0,0x28ba0d40,0x0,0x0,0x289a0d40,0x0,0x0,0x0,0x0,0x29ba0d40,0x0,0x0,0x6cfeef40,0x28ba0d40,0x28ba0d40,0x6cfeef40,0x28ba0d40,0x0,0x80000,0x80000,0x28ba0d40,0x0,0x0,0x0,0x0,0x289a0d40,0x80000,0x0,0x28ba0d40,0x28ba0d40,0x0,0x444ee3c0,0x444ee3c0,0x80,0xa0140,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x289a0d40,0x80,};
12448	}
12449	private static void jj_la1_init_2() {
12450	jj_la1_2 = new int[] {0x490,0x90,0x490,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200007ff,0x0,0x200007ff,0x200007ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200007ff,0x200007ff,0x0,0x200007ff,0x200007ff,0x0,0x0,0x0,0x2b021fff,0x2b021fff,0x0,0x0,0x0,0x0,0x0,0x0,0x200007ff,0x0,0x200007ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b021fff,0x0,0x0,0x200007ff,0x200007ff,0x0,0x200007ff,0x200007ff,0x0,0x0,0x0,0x200007ff,0x200007ff,0x0,0x200007ff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b021fff,0x0,0x0,0x2b021fff,0x0,0x0,0x200007ff,0x0,0x0,0x0,0x200007ff,0x0,0x0,0x2b021fff,0x0,0x200007ff,0x0,0xb021800,0x200007ff,0x0,0x0,0x0,0x0,0x0,0xb021800,0x0,0x2b021fff,0x0,0x0,0x0,0x200007ff,0x2b021fff,0x0,0x0,0x2b021fff,0x0,0x2b021fff,0x0,0x2b021fff,0x0,0x0,0x2b021fff,0x0,0x0,0x0,0x0,0x2b021fff,0x0,0x0,0x2b021fff,0x2b021fff,0x2b021fff,0x2b021fff,0x2b021fff,0x0,0x200007ff,0x200007ff,0x2b021fff,0x0,0x0,0x0,0x0,0x2b021fff,0x200007ff,0x0,0x2b021fff,0x2b021fff,0x0,0x200007ff,0x200007ff,0x0,0x200007ff,0x0,0x0,0x4,0x0,0x4,0x0,0x362,0x10,0x362,0x2b021fff,0x0,};
12451	}
12452	private static void jj_la1_init_3() {
12453	jj_la1_3 = new int[] {0x240,0x240,0x240,0x0,0x0,0x100,0x200,0x0,0x800,0x0,0x0,0x80,0x80,0x0,0x200,0x80,0xa44,0xa44,0x40,0x200,0x1,0x4,0x80,0x0,0x20000000,0xa44,0xa44,0x0,0xa00,0xa00,0x80,0x400,0x210,0x7803205,0x7803205,0x80,0x800,0x210,0x80,0x0,0x44,0x200,0x80,0x200,0x80,0x80,0x200,0x800,0x80,0x0,0x800,0x800,0xa01,0x0,0x0,0x0,0x200,0x80,0x4200,0x4000,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x10000,0x10400,0x400,0x4000,0x400000,0x200000,0x40000000,0x80000000,0x20000000,0x120000,0x120000,0x0,0xc0800,0xc0800,0x0,0x6000000,0x6000000,0x18000000,0x18000000,0x6000000,0x7803201,0x3000,0x3000,0x201,0x1800000,0x20000000,0x0,0x800,0x1,0x800,0x0,0x100,0x2,0x7803201,0x800,0x0,0x1,0x1,0x0,0x100,0x800,0x1,0x0,0x110,0x0,0x0,0x7803201,0x80,0x800,0x211,0x0,0x7803201,0x4,0x0,0x1800245,0x8000,0x1800245,0x80,0x7803205,0x1800400,0x1800400,0x1000201,0x0,0x0,0x80,0x0,0x7803205,0x18000,0x0,0x7803201,0x7803201,0x7803201,0x7803241,0x7803201,0x80,0x0,0x0,0x7803201,0x1,0x0,0x40000000,0x0,0x201,0x0,0x80,0x7803205,0x7803205,0x80,0x240,0x240,0x0,0x200,0x0,0x80,0x0,0x80,0x0,0x80,0x0,0x0,0x0,0xa01,0x200,};
12454	}
12455	private static void jj_la1_init_4() {
12456	jj_la1_4 = new int[] {0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x5ffc,0x1ffc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x20000,0x2,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1ffc,0x1ffc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
12457	}
12458	private final JJCalls[] jj_2_rtns = new JJCalls[59];
12459	private boolean jj_rescan = false;
12460	private int jj_gc = 0;
12461
12462	/**
12463	* Constructor with InputStream.
12464	* @param stream char stream
12465	*/
12466	public GeneratedJavaParser(final Provider stream) {
12467	jj_input_stream = new SimpleCharStream(stream, 1, 1);
12468	token_source = new GeneratedJavaParserTokenManager(jj_input_stream);
12469	token = new Token();
12470	jj_ntk = -1;
12471	jj_gen = 0;
12472	for (int i = 0; i < 170; i++)
12473	jj_la1[i] = -1;
12474	for (int i = 0; i < jj_2_rtns.length; i++)
12475	jj_2_rtns[i] = new JJCalls();
12476	}
12477
12478	/**
12479	* Constructor with InputStream.
12480	* @param sDSL String representation to be parsed
12481	*/
12482	public GeneratedJavaParser(final String sDSL) {
12483	this(new StringProvider(sDSL));
12484	}
12485
12486	/**
12487	* Reinitialise.
12488	* @param sDSL String representation to be parsed
12489	*/
12490	public void ReInit(final String sDSL) {
12491	ReInit(new StringProvider(sDSL));
12492	}
12493	/**
12494	* Reinitialise
12495	* @param stream char stream
12496	*/
12497	public void ReInit(final Provider stream) {
12498	if (jj_input_stream == null) {
12499	jj_input_stream = new SimpleCharStream(stream, 1, 1);
12500	} else {
12501	jj_input_stream.reInit(stream, 1, 1);
12502	}
12503	if (token_source == null) {
12504	token_source = new GeneratedJavaParserTokenManager(jj_input_stream);
12505	}
12506
12507	token_source.ReInit(jj_input_stream);
12508	token = new Token();
12509	jj_ntk = -1;
12510	jj_gen = 0;
12511	for (int i = 0; i < 170; i++)
12512	jj_la1[i] = -1;
12513	for (int i = 0; i < jj_2_rtns.length; i++)
12514	jj_2_rtns[i] = new JJCalls();
12515	}
12516
12517	/**
12518	* Constructor with generated Token Manager.
12519	* @param tm Token manager to use
12520	*/
12521	public GeneratedJavaParser(final GeneratedJavaParserTokenManager tm) {
12522	token_source = tm;
12523	token = new Token();
12524	jj_ntk = -1;
12525	jj_gen = 0;
12526	for (int i = 0; i < 170; i++) jj_la1[i] = -1;
12527	for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
12528	}
12529
12530	/**
12531	* Reinitialise
12532	* @param tm Token manager to use
12533	*/
12534	public void ReInit(final GeneratedJavaParserTokenManager tm) {
12535	token_source = tm;
12536	token = new Token();
12537	jj_ntk = -1;
12538	jj_gen = 0;
12539	for (int i = 0; i < 170; i++) jj_la1[i] = -1;
12540	for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
12541	}
12542
12543	private Token jj_consume_token(final int kind) throws ParseException {
12544	final Token oldToken = token;
12545	if (token.next != null)
12546	token = token.next;
12547	else {
12548	token.next = token_source.getNextToken();
12549	token = token.next;
12550	}
12551	jj_ntk = -1;
12552	if (token.kind == kind) {
12553	jj_gen++;
12554	if (++jj_gc > 100) {
12555	jj_gc = 0;
12556	for (int i = 0; i < jj_2_rtns.length; i++) {
12557	JJCalls c = jj_2_rtns[i];
12558	while (c != null) {
12559	if (c.gen < jj_gen)
12560	c.first = null;
12561	c = c.next;
12562	}
12563	}
12564	}
12565	return token;
12566	}
12567	token = oldToken;
12568	jj_kind = kind;
12569	throw generateParseException();
12570	}
12571
12572	private static final class LookaheadSuccess extends IllegalStateException {}
12573	private final LookaheadSuccess jj_ls = new LookaheadSuccess();
12574	private boolean jj_scan_token(int kind) {
12575	if (jj_scanpos == jj_lastpos) {
12576	jj_la--;
12577	if (jj_scanpos.next == null) {
12578	jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
12579	} else {
12580	jj_lastpos = jj_scanpos = jj_scanpos.next;
12581	}
12582	} else {
12583	jj_scanpos = jj_scanpos.next;
12584	}
12585	if (jj_rescan) {
12586	int i = 0; Token tok = token;
12587	while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
12588	if (tok != null) jj_add_error_token(kind, i);
12589	}
12590	if (jj_scanpos.kind != kind) return true;
12591	if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
12592	return false;
12593	}
12594
12595
12596	/**
12597	* @return the next Token.
12598	*/
12599	public final Token getNextToken() {
12600	if (token.next != null)
12601	token = token.next;
12602	else
12603	token = token.next = token_source.getNextToken();
12604	jj_ntk = -1;
12605	jj_gen++;
12606	return token;
12607	}
12608
12609	/**
12610	* @param index index to be retrieved
12611	* @return the specific Token.
12612	*/
12613	public final Token getToken(final int index) {
12614	Token t = jj_lookingAhead ? jj_scanpos : token;
12615	for (int i = 0; i < index; i++) {
12616	if (t.next == null)
12617	t.next = token_source.getNextToken();
12618	t = t.next;
12619	}
12620	return t;
12621	}
12622
12623	private int jj_ntk_f() {
12624	jj_nt = token.next;
12625	if (jj_nt == null) {
12626	token.next = token_source.getNextToken();
12627	jj_ntk = token.next.kind;
12628	return jj_ntk;
12629	}
12630	jj_ntk = jj_nt.kind;
12631	return jj_ntk;
12632	}
12633
12634	private java.util.List<int[]> jj_expentries = new java.util.ArrayList<>();
12635	private int[] jj_expentry;
12636	private int jj_kind = -1;
12637	private int[] jj_lasttokens = new int[100];
12638	private int jj_endpos;
12639
12640	private void jj_add_error_token(int kind, int pos) {
12641	if (pos >= 100) {
12642	return;
12643	}
12644
12645	if (pos == jj_endpos + 1) {
12646	jj_lasttokens[jj_endpos++] = kind;
12647	} else if (jj_endpos != 0) {
12648	jj_expentry = new int[jj_endpos];
12649
12650	for (int i = 0; i < jj_endpos; i++) {
12651	jj_expentry[i] = jj_lasttokens[i];
12652	}
12653
12654	for (final int[] oldentry : jj_expentries) {
12655	if (oldentry.length == jj_expentry.length) {
12656	boolean isMatched = true;
12657	for (int i = 0; i < jj_expentry.length; i++) {
12658	if (oldentry[i] != jj_expentry[i]) {
12659	isMatched = false;
12660	break;
12661	}
12662	}
12663	if (isMatched) {
12664	jj_expentries.add(jj_expentry);
12665	break;
12666	}
12667	}
12668	}
12669
12670	if (pos != 0) {
12671	jj_endpos = pos;
12672	jj_lasttokens[jj_endpos - 1] = kind;
12673	}
12674	}
12675	}
12676
12677	/**
12678	* Generate ParseException.
12679	* @return new Exception object. Never <code>null</code>
12680	*/
12681	public ParseException generateParseException() {
12682	jj_expentries.clear();
12683	boolean[] la1tokens = new boolean[147];
12684	if (jj_kind >= 0) {
12685	la1tokens[jj_kind] = true;
12686	jj_kind = -1;
12687	}
12688	for (int i = 0; i < 170; i++) {
12689	if (jj_la1[i] == jj_gen) {
12690	for (int j = 0; j < 32; j++) {
12691	if ((jj_la1_0[i] & (1<<j)) != 0) {
12692	la1tokens[j] = true;
12693	}
12694	if ((jj_la1_1[i] & (1<<j)) != 0) {
12695	la1tokens[32+j] = true;
12696	}
12697	if ((jj_la1_2[i] & (1<<j)) != 0) {
12698	la1tokens[64+j] = true;
12699	}
12700	if ((jj_la1_3[i] & (1<<j)) != 0) {
12701	la1tokens[96+j] = true;
12702	}
12703	if ((jj_la1_4[i] & (1<<j)) != 0) {
12704	la1tokens[128+j] = true;
12705	}
12706	}
12707	}
12708	}
12709	for (int i = 0; i < 147; i++) {
12710	if (la1tokens[i]) {
12711	jj_expentry = new int[1];
12712	jj_expentry[0] = i;
12713	jj_expentries.add(jj_expentry);
12714	}
12715	}
12716	jj_endpos = 0;
12717	jj_rescan_token();
12718	jj_add_error_token(0, 0);
12719	int[][] exptokseq = new int[jj_expentries.size()][];
12720	for (int i = 0; i < jj_expentries.size(); i++) {
12721	exptokseq[i] = jj_expentries.get(i);
12722	}
12723	return new ParseException(token, exptokseq, tokenImage, token_source == null ? null : GeneratedJavaParserTokenManager.lexStateNames[token_source.curLexState]);
12724	}
12725
12726	/**
12727	* @return Always <code>false</code>.
12728	*/
12729	public final boolean trace_enabled() {
12730	return false;
12731	}
12732
12733	/** Enable tracing. */
12734	public final void enable_tracing() {}
12735
12736	/** Disable tracing. */
12737	public final void disable_tracing() {}
12738
12739	private void jj_rescan_token() {
12740	jj_rescan = true;
12741	for (int i = 0; i < 59; i++) {
12742	try {
12743	JJCalls p = jj_2_rtns[i];
12744	do {
12745	if (p.gen > jj_gen) {
12746	jj_la = p.arg;
12747	jj_scanpos = p.first;
12748	jj_lastpos = p.first;
12749	switch (i) {
12750	case 0: jj_3_1(); break;
12751	case 1: jj_3_2(); break;
12752	case 2: jj_3_3(); break;
12753	case 3: jj_3_4(); break;
12754	case 4: jj_3_5(); break;
12755	case 5: jj_3_6(); break;
12756	case 6: jj_3_7(); break;
12757	case 7: jj_3_8(); break;
12758	case 8: jj_3_9(); break;
12759	case 9: jj_3_10(); break;
12760	case 10: jj_3_11(); break;
12761	case 11: jj_3_12(); break;
12762	case 12: jj_3_13(); break;
12763	case 13: jj_3_14(); break;
12764	case 14: jj_3_15(); break;
12765	case 15: jj_3_16(); break;
12766	case 16: jj_3_17(); break;
12767	case 17: jj_3_18(); break;
12768	case 18: jj_3_19(); break;
12769	case 19: jj_3_20(); break;
12770	case 20: jj_3_21(); break;
12771	case 21: jj_3_22(); break;
12772	case 22: jj_3_23(); break;
12773	case 23: jj_3_24(); break;
12774	case 24: jj_3_25(); break;
12775	case 25: jj_3_26(); break;
12776	case 26: jj_3_27(); break;
12777	case 27: jj_3_28(); break;
12778	case 28: jj_3_29(); break;
12779	case 29: jj_3_30(); break;
12780	case 30: jj_3_31(); break;
12781	case 31: jj_3_32(); break;
12782	case 32: jj_3_33(); break;
12783	case 33: jj_3_34(); break;
12784	case 34: jj_3_35(); break;
12785	case 35: jj_3_36(); break;
12786	case 36: jj_3_37(); break;
12787	case 37: jj_3_38(); break;
12788	case 38: jj_3_39(); break;
12789	case 39: jj_3_40(); break;
12790	case 40: jj_3_41(); break;
12791	case 41: jj_3_42(); break;
12792	case 42: jj_3_43(); break;
12793	case 43: jj_3_44(); break;
12794	case 44: jj_3_45(); break;
12795	case 45: jj_3_46(); break;
12796	case 46: jj_3_47(); break;
12797	case 47: jj_3_48(); break;
12798	case 48: jj_3_49(); break;
12799	case 49: jj_3_50(); break;
12800	case 50: jj_3_51(); break;
12801	case 51: jj_3_52(); break;
12802	case 52: jj_3_53(); break;
12803	case 53: jj_3_54(); break;
12804	case 54: jj_3_55(); break;
12805	case 55: jj_3_56(); break;
12806	case 56: jj_3_57(); break;
12807	case 57: jj_3_58(); break;
12808	case 58: jj_3_59(); break;
12809	}
12810	}
12811	p = p.next;
12812	} while (p != null);
12813	} catch(LookaheadSuccess ls) { /* ignore */ }
12814	}
12815	jj_rescan = false;
12816	}
12817
12818	private void jj_save(int index, int xla) {
12819	JJCalls p = jj_2_rtns[index];
12820	while (p.gen > jj_gen) {
12821	if (p.next == null) {
12822	p.next = new JJCalls();
12823	p = p.next;
12824	break;
12825	}
12826	p = p.next;
12827	}
12828	p.gen = jj_gen + xla - jj_la;
12829	p.first = token;
12830	p.arg = xla;
12831	}
12832
12833	static final class JJCalls {
12834	int gen;
12835	Token first;
12836	int arg;
12837	JJCalls next;
12838	}
12839
12840	}
12841