View Javadoc
1   // $ANTLR 2.7.7 (20060906): "java.g" -> "GeneratedJavaRecognizer.java"$
2   
3   package com.puppycrawl.tools.checkstyle.grammars;
4   
5   import com.puppycrawl.tools.checkstyle.api.DetailAST;
6   import java.text.MessageFormat;
7   import antlr.CommonHiddenStreamToken;
8   
9   import antlr.TokenBuffer;
10  import antlr.TokenStreamException;
11  import antlr.TokenStreamIOException;
12  import antlr.ANTLRException;
13  import antlr.LLkParser;
14  import antlr.Token;
15  import antlr.TokenStream;
16  import antlr.RecognitionException;
17  import antlr.NoViableAltException;
18  import antlr.MismatchedTokenException;
19  import antlr.SemanticException;
20  import antlr.ParserSharedInputState;
21  import antlr.collections.impl.BitSet;
22  import antlr.collections.AST;
23  import java.util.Hashtable;
24  import antlr.ASTFactory;
25  import antlr.ASTPair;
26  import antlr.collections.impl.ASTArray;
27  
28  /** Java 1.5 Recognizer
29   *
30   * This grammar is in the PUBLIC DOMAIN
31   */
32  public class GeneratedJavaRecognizer extends antlr.LLkParser       implements GeneratedJavaTokenTypes
33   {
34  
35      /**
36       * Counts the number of LT seen in the typeArguments production.
37       * It is used in semantic predicates to ensure we have seen
38       * enough closing '>' characters; which actually may have been
39       * either GT, SR or BSR tokens.
40       */
41      private int ltCounter = 0;
42  
43      /**
44       * Counts the number of '>' characters that have been seen but
45       * have not yet been associated with the end of a typeParameters or
46       * typeArguments production. This is necessary because SR and BSR
47       * tokens have significance (the extra '>' characters) not only for the production
48       * that sees them but also productions higher in the stack (possibly right up to an outer-most
49       * typeParameters production). As the stack of the typeArguments/typeParameters productions
50       * unwind, any '>' characters seen prematurely through SRs or BSRs are reconciled.
51       */
52      private int gtToReconcile = 0;
53  
54      /**
55       * The most recently seen gt sequence (GT, SR or BSR)
56       * encountered in any type argument or type parameter production.
57       * We retain this so we can keep manage the synthetic GT tokens/
58       * AST nodes we emit to have '<' & '>' balanced trees when encountering
59       * SR and BSR tokens.
60       */
61      private DetailAST currentGtSequence = null;
62  
63      /**
64       * Consume a sequence of '>' characters (GT, SR or BSR)
65       * and match these against the '<' characters seen.
66       */
67      private void consumeCurrentGtSequence(DetailAST gtSequence)
68      {
69          currentGtSequence = gtSequence;
70          gtToReconcile += currentGtSequence.getText().length();
71          ltCounter -= currentGtSequence.getText().length();
72      }
73  
74      /**
75       * Emits a single GT AST node with the line and column correctly
76       * set to its position in the source file. This must only
77       * ever be called when a typeParameters or typeArguments production
78       * is ending and there is at least one GT character to be emitted.
79       *
80       * @see #areThereGtsToEmit
81       */
82      private DetailAST emitSingleGt()
83      {
84          gtToReconcile -= 1;
85          CommonHiddenStreamToken gtToken = new CommonHiddenStreamToken(GENERIC_END, ">");
86          gtToken.setLine(currentGtSequence.getLineNo());
87          gtToken.setColumn(currentGtSequence.getColumnNo()
88                              + (currentGtSequence.getText().length() - gtToReconcile));
89          return (DetailAST)astFactory.create(gtToken);
90      }
91  
92      /**
93       * @return true if there is at least one '>' seen but
94       * not reconciled with the end of a typeParameters or
95       * typeArguments production; returns false otherwise
96       */
97      private boolean areThereGtsToEmit()
98      {
99          return (gtToReconcile > 0);
100     }
101 
102     /**
103      * @return true if there is exactly one '>' seen but
104      * not reconciled with the end of a typeParameters
105      * production; returns false otherwise
106      */
107     private boolean isThereASingleGtToEmit()
108     {
109         return (gtToReconcile == 1);
110     }
111 
112     /**
113      * @return true if the '<' and '>' are evenly matched
114      * at the current typeParameters/typeArguments nested depth
115      */
116     private boolean areLtsAndGtsBalanced(int currentLtLevel)
117     {
118         return ((currentLtLevel != 0) || ltCounter == currentLtLevel);
119     }
120 
121 protected GeneratedJavaRecognizer(TokenBuffer tokenBuf, int k) {
122   super(tokenBuf,k);
123   tokenNames = _tokenNames;
124   buildTokenTypeASTClassMap();
125   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
126 }
127 
128 public GeneratedJavaRecognizer(TokenBuffer tokenBuf) {
129   this(tokenBuf,2);
130 }
131 
132 protected GeneratedJavaRecognizer(TokenStream lexer, int k) {
133   super(lexer,k);
134   tokenNames = _tokenNames;
135   buildTokenTypeASTClassMap();
136   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
137 }
138 
139 public GeneratedJavaRecognizer(TokenStream lexer) {
140   this(lexer,2);
141 }
142 
143 public GeneratedJavaRecognizer(ParserSharedInputState state) {
144   super(state,2);
145   tokenNames = _tokenNames;
146   buildTokenTypeASTClassMap();
147   astFactory = new ASTFactory(getTokenTypeToASTClassMap());
148 }
149 
150 	public final void compilationUnit() throws RecognitionException, TokenStreamException {
151 		
152 		returnAST = null;
153 		ASTPair currentAST = new ASTPair();
154 		AST compilationUnit_AST = null;
155 		
156 		{
157 		boolean synPredMatched4 = false;
158 		if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT))) {
159 			int _m4 = mark();
160 			synPredMatched4 = true;
161 			inputState.guessing++;
162 			try {
163 				{
164 				annotations();
165 				match(LITERAL_package);
166 				}
167 			}
168 			catch (RecognitionException pe) {
169 				synPredMatched4 = false;
170 			}
171 			rewind(_m4);
172 inputState.guessing--;
173 		}
174 		if ( synPredMatched4 ) {
175 			packageDefinition();
176 			astFactory.addASTChild(currentAST, returnAST);
177 		}
178 		else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
179 		}
180 		else {
181 			throw new NoViableAltException(LT(1), getFilename());
182 		}
183 		
184 		}
185 		{
186 		_loop6:
187 		do {
188 			if ((LA(1)==SEMI||LA(1)==LITERAL_import) && (_tokenSet_1.member(LA(2)))) {
189 				importDefinition();
190 				astFactory.addASTChild(currentAST, returnAST);
191 			}
192 			else {
193 				break _loop6;
194 			}
195 			
196 		} while (true);
197 		}
198 		{
199 		_loop8:
200 		do {
201 			if ((_tokenSet_2.member(LA(1)))) {
202 				typeDefinition();
203 				astFactory.addASTChild(currentAST, returnAST);
204 			}
205 			else {
206 				break _loop8;
207 			}
208 			
209 		} while (true);
210 		}
211 		match(Token.EOF_TYPE);
212 		compilationUnit_AST = (AST)currentAST.root;
213 		returnAST = compilationUnit_AST;
214 	}
215 	
216 	public final void annotations() throws RecognitionException, TokenStreamException {
217 		
218 		returnAST = null;
219 		ASTPair currentAST = new ASTPair();
220 		AST annotations_AST = null;
221 		
222 		{
223 		_loop68:
224 		do {
225 			if ((LA(1)==AT) && (LA(2)==IDENT)) {
226 				annotation();
227 				astFactory.addASTChild(currentAST, returnAST);
228 			}
229 			else {
230 				break _loop68;
231 			}
232 			
233 		} while (true);
234 		}
235 		if ( inputState.guessing==0 ) {
236 			annotations_AST = (AST)currentAST.root;
237 			annotations_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ANNOTATIONS,"ANNOTATIONS")).add(annotations_AST));
238 			currentAST.root = annotations_AST;
239 			currentAST.child = annotations_AST!=null &&annotations_AST.getFirstChild()!=null ?
240 				annotations_AST.getFirstChild() : annotations_AST;
241 			currentAST.advanceChildToEnd();
242 		}
243 		annotations_AST = (AST)currentAST.root;
244 		returnAST = annotations_AST;
245 	}
246 	
247 	public final void packageDefinition() throws RecognitionException, TokenStreamException {
248 		
249 		returnAST = null;
250 		ASTPair currentAST = new ASTPair();
251 		AST packageDefinition_AST = null;
252 		Token  p = null;
253 		AST p_AST = null;
254 		
255 		try {      // for error handling
256 			annotations();
257 			astFactory.addASTChild(currentAST, returnAST);
258 			p = LT(1);
259 			p_AST = astFactory.create(p);
260 			astFactory.makeASTRoot(currentAST, p_AST);
261 			match(LITERAL_package);
262 			if ( inputState.guessing==0 ) {
263 				p_AST.setType(PACKAGE_DEF);
264 			}
265 			identifier();
266 			astFactory.addASTChild(currentAST, returnAST);
267 			AST tmp2_AST = null;
268 			tmp2_AST = astFactory.create(LT(1));
269 			astFactory.addASTChild(currentAST, tmp2_AST);
270 			match(SEMI);
271 			packageDefinition_AST = (AST)currentAST.root;
272 		}
273 		catch (RecognitionException ex) {
274 			if (inputState.guessing==0) {
275 				reportError(ex);
276 				recover(ex,_tokenSet_0);
277 			} else {
278 			  throw ex;
279 			}
280 		}
281 		returnAST = packageDefinition_AST;
282 	}
283 	
284 	public final void importDefinition() throws RecognitionException, TokenStreamException {
285 		
286 		returnAST = null;
287 		ASTPair currentAST = new ASTPair();
288 		AST importDefinition_AST = null;
289 		Token  i = null;
290 		AST i_AST = null;
291 		
292 		try {      // for error handling
293 			switch ( LA(1)) {
294 			case LITERAL_import:
295 			{
296 				i = LT(1);
297 				i_AST = astFactory.create(i);
298 				astFactory.makeASTRoot(currentAST, i_AST);
299 				match(LITERAL_import);
300 				if ( inputState.guessing==0 ) {
301 					i_AST.setType(IMPORT);
302 				}
303 				{
304 				switch ( LA(1)) {
305 				case LITERAL_static:
306 				{
307 					AST tmp3_AST = null;
308 					tmp3_AST = astFactory.create(LT(1));
309 					astFactory.addASTChild(currentAST, tmp3_AST);
310 					match(LITERAL_static);
311 					if ( inputState.guessing==0 ) {
312 						i_AST.setType(STATIC_IMPORT);
313 					}
314 					break;
315 				}
316 				case IDENT:
317 				{
318 					break;
319 				}
320 				default:
321 				{
322 					throw new NoViableAltException(LT(1), getFilename());
323 				}
324 				}
325 				}
326 				identifierStar();
327 				astFactory.addASTChild(currentAST, returnAST);
328 				AST tmp4_AST = null;
329 				tmp4_AST = astFactory.create(LT(1));
330 				astFactory.addASTChild(currentAST, tmp4_AST);
331 				match(SEMI);
332 				importDefinition_AST = (AST)currentAST.root;
333 				break;
334 			}
335 			case SEMI:
336 			{
337 				AST tmp5_AST = null;
338 				tmp5_AST = astFactory.create(LT(1));
339 				astFactory.addASTChild(currentAST, tmp5_AST);
340 				match(SEMI);
341 				importDefinition_AST = (AST)currentAST.root;
342 				break;
343 			}
344 			default:
345 			{
346 				throw new NoViableAltException(LT(1), getFilename());
347 			}
348 			}
349 		}
350 		catch (RecognitionException ex) {
351 			if (inputState.guessing==0) {
352 				reportError(ex);
353 				recover(ex,_tokenSet_0);
354 			} else {
355 			  throw ex;
356 			}
357 		}
358 		returnAST = importDefinition_AST;
359 	}
360 	
361 	public final void typeDefinition() throws RecognitionException, TokenStreamException {
362 		
363 		returnAST = null;
364 		ASTPair currentAST = new ASTPair();
365 		AST typeDefinition_AST = null;
366 		AST m_AST = null;
367 		
368 		try {      // for error handling
369 			switch ( LA(1)) {
370 			case FINAL:
371 			case ABSTRACT:
372 			case STRICTFP:
373 			case LITERAL_private:
374 			case LITERAL_public:
375 			case LITERAL_protected:
376 			case LITERAL_static:
377 			case LITERAL_transient:
378 			case LITERAL_native:
379 			case LITERAL_synchronized:
380 			case LITERAL_volatile:
381 			case LITERAL_class:
382 			case LITERAL_interface:
383 			case LITERAL_default:
384 			case ENUM:
385 			case AT:
386 			{
387 				modifiers();
388 				m_AST = (AST)returnAST;
389 				typeDefinitionInternal(m_AST);
390 				astFactory.addASTChild(currentAST, returnAST);
391 				typeDefinition_AST = (AST)currentAST.root;
392 				break;
393 			}
394 			case SEMI:
395 			{
396 				AST tmp6_AST = null;
397 				tmp6_AST = astFactory.create(LT(1));
398 				astFactory.addASTChild(currentAST, tmp6_AST);
399 				match(SEMI);
400 				typeDefinition_AST = (AST)currentAST.root;
401 				break;
402 			}
403 			default:
404 			{
405 				throw new NoViableAltException(LT(1), getFilename());
406 			}
407 			}
408 		}
409 		catch (RecognitionException ex) {
410 			if (inputState.guessing==0) {
411 				reportError(ex);
412 				recover(ex,_tokenSet_3);
413 			} else {
414 			  throw ex;
415 			}
416 		}
417 		returnAST = typeDefinition_AST;
418 	}
419 	
420 	public final void identifier() throws RecognitionException, TokenStreamException {
421 		
422 		returnAST = null;
423 		ASTPair currentAST = new ASTPair();
424 		AST identifier_AST = null;
425 		
426 		AST tmp7_AST = null;
427 		tmp7_AST = astFactory.create(LT(1));
428 		astFactory.addASTChild(currentAST, tmp7_AST);
429 		match(IDENT);
430 		{
431 		_loop54:
432 		do {
433 			if ((LA(1)==DOT)) {
434 				AST tmp8_AST = null;
435 				tmp8_AST = astFactory.create(LT(1));
436 				astFactory.makeASTRoot(currentAST, tmp8_AST);
437 				match(DOT);
438 				AST tmp9_AST = null;
439 				tmp9_AST = astFactory.create(LT(1));
440 				astFactory.addASTChild(currentAST, tmp9_AST);
441 				match(IDENT);
442 			}
443 			else {
444 				break _loop54;
445 			}
446 			
447 		} while (true);
448 		}
449 		identifier_AST = (AST)currentAST.root;
450 		returnAST = identifier_AST;
451 	}
452 	
453 	public final void identifierStar() throws RecognitionException, TokenStreamException {
454 		
455 		returnAST = null;
456 		ASTPair currentAST = new ASTPair();
457 		AST identifierStar_AST = null;
458 		
459 		AST tmp10_AST = null;
460 		tmp10_AST = astFactory.create(LT(1));
461 		astFactory.addASTChild(currentAST, tmp10_AST);
462 		match(IDENT);
463 		{
464 		_loop57:
465 		do {
466 			if ((LA(1)==DOT) && (LA(2)==IDENT)) {
467 				AST tmp11_AST = null;
468 				tmp11_AST = astFactory.create(LT(1));
469 				astFactory.makeASTRoot(currentAST, tmp11_AST);
470 				match(DOT);
471 				AST tmp12_AST = null;
472 				tmp12_AST = astFactory.create(LT(1));
473 				astFactory.addASTChild(currentAST, tmp12_AST);
474 				match(IDENT);
475 			}
476 			else {
477 				break _loop57;
478 			}
479 			
480 		} while (true);
481 		}
482 		{
483 		switch ( LA(1)) {
484 		case DOT:
485 		{
486 			AST tmp13_AST = null;
487 			tmp13_AST = astFactory.create(LT(1));
488 			astFactory.makeASTRoot(currentAST, tmp13_AST);
489 			match(DOT);
490 			AST tmp14_AST = null;
491 			tmp14_AST = astFactory.create(LT(1));
492 			astFactory.addASTChild(currentAST, tmp14_AST);
493 			match(STAR);
494 			break;
495 		}
496 		case SEMI:
497 		{
498 			break;
499 		}
500 		default:
501 		{
502 			throw new NoViableAltException(LT(1), getFilename());
503 		}
504 		}
505 		}
506 		identifierStar_AST = (AST)currentAST.root;
507 		returnAST = identifierStar_AST;
508 	}
509 	
510 	public final void modifiers() throws RecognitionException, TokenStreamException {
511 		
512 		returnAST = null;
513 		ASTPair currentAST = new ASTPair();
514 		AST modifiers_AST = null;
515 		
516 		{
517 		_loop61:
518 		do {
519 			if ((_tokenSet_4.member(LA(1)))) {
520 				modifier();
521 				astFactory.addASTChild(currentAST, returnAST);
522 			}
523 			else if (((LA(1)==AT) && (LA(2)==IDENT))&&(LA(1)==AT && !LT(2).getText().equals("interface"))) {
524 				annotation();
525 				astFactory.addASTChild(currentAST, returnAST);
526 			}
527 			else {
528 				break _loop61;
529 			}
530 			
531 		} while (true);
532 		}
533 		if ( inputState.guessing==0 ) {
534 			modifiers_AST = (AST)currentAST.root;
535 			modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(modifiers_AST));
536 			currentAST.root = modifiers_AST;
537 			currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
538 				modifiers_AST.getFirstChild() : modifiers_AST;
539 			currentAST.advanceChildToEnd();
540 		}
541 		modifiers_AST = (AST)currentAST.root;
542 		returnAST = modifiers_AST;
543 	}
544 	
545 	protected final void typeDefinitionInternal(
546 		AST modifiers
547 	) throws RecognitionException, TokenStreamException {
548 		
549 		returnAST = null;
550 		ASTPair currentAST = new ASTPair();
551 		AST typeDefinitionInternal_AST = null;
552 		
553 		switch ( LA(1)) {
554 		case LITERAL_class:
555 		{
556 			classDefinition(modifiers);
557 			astFactory.addASTChild(currentAST, returnAST);
558 			typeDefinitionInternal_AST = (AST)currentAST.root;
559 			break;
560 		}
561 		case LITERAL_interface:
562 		{
563 			interfaceDefinition(modifiers);
564 			astFactory.addASTChild(currentAST, returnAST);
565 			typeDefinitionInternal_AST = (AST)currentAST.root;
566 			break;
567 		}
568 		case ENUM:
569 		{
570 			enumDefinition(modifiers);
571 			astFactory.addASTChild(currentAST, returnAST);
572 			typeDefinitionInternal_AST = (AST)currentAST.root;
573 			break;
574 		}
575 		case AT:
576 		{
577 			annotationDefinition(modifiers);
578 			astFactory.addASTChild(currentAST, returnAST);
579 			typeDefinitionInternal_AST = (AST)currentAST.root;
580 			break;
581 		}
582 		default:
583 		{
584 			throw new NoViableAltException(LT(1), getFilename());
585 		}
586 		}
587 		returnAST = typeDefinitionInternal_AST;
588 	}
589 	
590 	public final void classDefinition(
591 		AST modifiers
592 	) throws RecognitionException, TokenStreamException {
593 		
594 		returnAST = null;
595 		ASTPair currentAST = new ASTPair();
596 		AST classDefinition_AST = null;
597 		Token  c = null;
598 		AST c_AST = null;
599 		AST tp_AST = null;
600 		AST sc_AST = null;
601 		AST ic_AST = null;
602 		AST cb_AST = null;
603 		
604 		c = LT(1);
605 		c_AST = astFactory.create(c);
606 		match(LITERAL_class);
607 		AST tmp15_AST = null;
608 		tmp15_AST = astFactory.create(LT(1));
609 		match(IDENT);
610 		{
611 		switch ( LA(1)) {
612 		case LT:
613 		{
614 			typeParameters();
615 			tp_AST = (AST)returnAST;
616 			break;
617 		}
618 		case LITERAL_extends:
619 		case LCURLY:
620 		case LITERAL_implements:
621 		{
622 			break;
623 		}
624 		default:
625 		{
626 			throw new NoViableAltException(LT(1), getFilename());
627 		}
628 		}
629 		}
630 		superClassClause();
631 		sc_AST = (AST)returnAST;
632 		implementsClause();
633 		ic_AST = (AST)returnAST;
634 		classBlock();
635 		cb_AST = (AST)returnAST;
636 		if ( inputState.guessing==0 ) {
637 			classDefinition_AST = (AST)currentAST.root;
638 			classDefinition_AST = (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(CLASS_DEF,"CLASS_DEF")).add(modifiers).add(c_AST).add(tmp15_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST));
639 			currentAST.root = classDefinition_AST;
640 			currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
641 				classDefinition_AST.getFirstChild() : classDefinition_AST;
642 			currentAST.advanceChildToEnd();
643 		}
644 		returnAST = classDefinition_AST;
645 	}
646 	
647 	public final void interfaceDefinition(
648 		AST modifiers
649 	) throws RecognitionException, TokenStreamException {
650 		
651 		returnAST = null;
652 		ASTPair currentAST = new ASTPair();
653 		AST interfaceDefinition_AST = null;
654 		Token  i = null;
655 		AST i_AST = null;
656 		AST tp_AST = null;
657 		AST ie_AST = null;
658 		AST cb_AST = null;
659 		
660 		i = LT(1);
661 		i_AST = astFactory.create(i);
662 		match(LITERAL_interface);
663 		AST tmp16_AST = null;
664 		tmp16_AST = astFactory.create(LT(1));
665 		match(IDENT);
666 		{
667 		switch ( LA(1)) {
668 		case LT:
669 		{
670 			typeParameters();
671 			tp_AST = (AST)returnAST;
672 			break;
673 		}
674 		case LITERAL_extends:
675 		case LCURLY:
676 		{
677 			break;
678 		}
679 		default:
680 		{
681 			throw new NoViableAltException(LT(1), getFilename());
682 		}
683 		}
684 		}
685 		interfaceExtends();
686 		ie_AST = (AST)returnAST;
687 		classBlock();
688 		cb_AST = (AST)returnAST;
689 		if ( inputState.guessing==0 ) {
690 			interfaceDefinition_AST = (AST)currentAST.root;
691 			interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(INTERFACE_DEF,"INTERFACE_DEF")).add(modifiers).add(i_AST).add(tmp16_AST).add(tp_AST).add(ie_AST).add(cb_AST));
692 			currentAST.root = interfaceDefinition_AST;
693 			currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
694 				interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
695 			currentAST.advanceChildToEnd();
696 		}
697 		returnAST = interfaceDefinition_AST;
698 	}
699 	
700 	public final void enumDefinition(
701 		AST modifiers
702 	) throws RecognitionException, TokenStreamException {
703 		
704 		returnAST = null;
705 		ASTPair currentAST = new ASTPair();
706 		AST enumDefinition_AST = null;
707 		Token  e = null;
708 		AST e_AST = null;
709 		AST ic_AST = null;
710 		AST eb_AST = null;
711 		
712 		e = LT(1);
713 		e_AST = astFactory.create(e);
714 		match(ENUM);
715 		AST tmp17_AST = null;
716 		tmp17_AST = astFactory.create(LT(1));
717 		match(IDENT);
718 		implementsClause();
719 		ic_AST = (AST)returnAST;
720 		enumBlock();
721 		eb_AST = (AST)returnAST;
722 		if ( inputState.guessing==0 ) {
723 			enumDefinition_AST = (AST)currentAST.root;
724 			enumDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ENUM_DEF,"ENUM_DEF")).add(modifiers).add(e_AST).add(tmp17_AST).add(ic_AST).add(eb_AST));
725 			currentAST.root = enumDefinition_AST;
726 			currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ?
727 				enumDefinition_AST.getFirstChild() : enumDefinition_AST;
728 			currentAST.advanceChildToEnd();
729 		}
730 		returnAST = enumDefinition_AST;
731 	}
732 	
733 	public final void annotationDefinition(
734 		AST modifiers
735 	) throws RecognitionException, TokenStreamException {
736 		
737 		returnAST = null;
738 		ASTPair currentAST = new ASTPair();
739 		AST annotationDefinition_AST = null;
740 		Token  a = null;
741 		AST a_AST = null;
742 		Token  i = null;
743 		AST i_AST = null;
744 		AST ab_AST = null;
745 		
746 		a = LT(1);
747 		a_AST = astFactory.create(a);
748 		match(AT);
749 		i = LT(1);
750 		i_AST = astFactory.create(i);
751 		match(LITERAL_interface);
752 		AST tmp18_AST = null;
753 		tmp18_AST = astFactory.create(LT(1));
754 		match(IDENT);
755 		annotationBlock();
756 		ab_AST = (AST)returnAST;
757 		if ( inputState.guessing==0 ) {
758 			annotationDefinition_AST = (AST)currentAST.root;
759 			annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION_DEF,"ANNOTATION_DEF")).add(modifiers).add(a_AST).add(i_AST).add(tmp18_AST).add(ab_AST));
760 			currentAST.root = annotationDefinition_AST;
761 			currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ?
762 				annotationDefinition_AST.getFirstChild() : annotationDefinition_AST;
763 			currentAST.advanceChildToEnd();
764 		}
765 		returnAST = annotationDefinition_AST;
766 	}
767 	
768 	public final void typeSpec(
769 		boolean addImagNode
770 	) throws RecognitionException, TokenStreamException {
771 		
772 		returnAST = null;
773 		ASTPair currentAST = new ASTPair();
774 		AST typeSpec_AST = null;
775 		
776 		switch ( LA(1)) {
777 		case IDENT:
778 		case AT:
779 		{
780 			classTypeSpec(addImagNode);
781 			astFactory.addASTChild(currentAST, returnAST);
782 			typeSpec_AST = (AST)currentAST.root;
783 			break;
784 		}
785 		case LITERAL_void:
786 		case LITERAL_boolean:
787 		case LITERAL_byte:
788 		case LITERAL_char:
789 		case LITERAL_short:
790 		case LITERAL_int:
791 		case LITERAL_float:
792 		case LITERAL_long:
793 		case LITERAL_double:
794 		{
795 			builtInTypeSpec(addImagNode);
796 			astFactory.addASTChild(currentAST, returnAST);
797 			typeSpec_AST = (AST)currentAST.root;
798 			break;
799 		}
800 		default:
801 		{
802 			throw new NoViableAltException(LT(1), getFilename());
803 		}
804 		}
805 		returnAST = typeSpec_AST;
806 	}
807 	
808 	public final void classTypeSpec(
809 		boolean addImagNode
810 	) throws RecognitionException, TokenStreamException {
811 		
812 		returnAST = null;
813 		ASTPair currentAST = new ASTPair();
814 		AST classTypeSpec_AST = null;
815 		Token  lb = null;
816 		AST lb_AST = null;
817 		
818 		classOrInterfaceType(addImagNode);
819 		astFactory.addASTChild(currentAST, returnAST);
820 		{
821 		_loop18:
822 		do {
823 			if ((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT)) {
824 				{
825 				if (((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT))&&(LA(1) == AT)) {
826 					annotations();
827 					astFactory.addASTChild(currentAST, returnAST);
828 				}
829 				else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
830 				}
831 				else {
832 					throw new NoViableAltException(LT(1), getFilename());
833 				}
834 				
835 				}
836 				lb = LT(1);
837 				lb_AST = astFactory.create(lb);
838 				astFactory.makeASTRoot(currentAST, lb_AST);
839 				match(LBRACK);
840 				if ( inputState.guessing==0 ) {
841 					lb_AST.setType(ARRAY_DECLARATOR);
842 				}
843 				AST tmp19_AST = null;
844 				tmp19_AST = astFactory.create(LT(1));
845 				astFactory.addASTChild(currentAST, tmp19_AST);
846 				match(RBRACK);
847 			}
848 			else {
849 				break _loop18;
850 			}
851 			
852 		} while (true);
853 		}
854 		if ( inputState.guessing==0 ) {
855 			classTypeSpec_AST = (AST)currentAST.root;
856 			
857 			if ( addImagNode ) {
858 			classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(classTypeSpec_AST));
859 			}
860 			
861 			currentAST.root = classTypeSpec_AST;
862 			currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ?
863 				classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
864 			currentAST.advanceChildToEnd();
865 		}
866 		classTypeSpec_AST = (AST)currentAST.root;
867 		returnAST = classTypeSpec_AST;
868 	}
869 	
870 	public final void builtInTypeSpec(
871 		boolean addImagNode
872 	) throws RecognitionException, TokenStreamException {
873 		
874 		returnAST = null;
875 		ASTPair currentAST = new ASTPair();
876 		AST builtInTypeSpec_AST = null;
877 		Token  lb = null;
878 		AST lb_AST = null;
879 		
880 		builtInType();
881 		astFactory.addASTChild(currentAST, returnAST);
882 		{
883 		_loop48:
884 		do {
885 			if ((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT)) {
886 				{
887 				if (((LA(1)==LBRACK||LA(1)==AT) && (LA(2)==RBRACK||LA(2)==IDENT))&&(LA(1) == AT)) {
888 					annotations();
889 					astFactory.addASTChild(currentAST, returnAST);
890 				}
891 				else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
892 				}
893 				else {
894 					throw new NoViableAltException(LT(1), getFilename());
895 				}
896 				
897 				}
898 				lb = LT(1);
899 				lb_AST = astFactory.create(lb);
900 				astFactory.makeASTRoot(currentAST, lb_AST);
901 				match(LBRACK);
902 				if ( inputState.guessing==0 ) {
903 					lb_AST.setType(ARRAY_DECLARATOR);
904 				}
905 				AST tmp20_AST = null;
906 				tmp20_AST = astFactory.create(LT(1));
907 				astFactory.addASTChild(currentAST, tmp20_AST);
908 				match(RBRACK);
909 			}
910 			else {
911 				break _loop48;
912 			}
913 			
914 		} while (true);
915 		}
916 		if ( inputState.guessing==0 ) {
917 			builtInTypeSpec_AST = (AST)currentAST.root;
918 			
919 			if ( addImagNode ) {
920 			builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeSpec_AST));
921 			}
922 			
923 			currentAST.root = builtInTypeSpec_AST;
924 			currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
925 				builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
926 			currentAST.advanceChildToEnd();
927 		}
928 		builtInTypeSpec_AST = (AST)currentAST.root;
929 		returnAST = builtInTypeSpec_AST;
930 	}
931 	
932 	public final void classOrInterfaceType(
933 		boolean addImagNode
934 	) throws RecognitionException, TokenStreamException {
935 		
936 		returnAST = null;
937 		ASTPair currentAST = new ASTPair();
938 		AST classOrInterfaceType_AST = null;
939 		
940 		{
941 		if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
942 			annotations();
943 			astFactory.addASTChild(currentAST, returnAST);
944 		}
945 		else if ((LA(1)==IDENT) && (_tokenSet_5.member(LA(2)))) {
946 		}
947 		else {
948 			throw new NoViableAltException(LT(1), getFilename());
949 		}
950 		
951 		}
952 		AST tmp21_AST = null;
953 		tmp21_AST = astFactory.create(LT(1));
954 		astFactory.addASTChild(currentAST, tmp21_AST);
955 		match(IDENT);
956 		{
957 		if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) {
958 			typeArguments(addImagNode);
959 			astFactory.addASTChild(currentAST, returnAST);
960 		}
961 		else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
962 		}
963 		else {
964 			throw new NoViableAltException(LT(1), getFilename());
965 		}
966 		
967 		}
968 		{
969 		_loop25:
970 		do {
971 			if ((LA(1)==DOT) && (LA(2)==IDENT||LA(2)==AT)) {
972 				AST tmp22_AST = null;
973 				tmp22_AST = astFactory.create(LT(1));
974 				astFactory.makeASTRoot(currentAST, tmp22_AST);
975 				match(DOT);
976 				{
977 				if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
978 					annotations();
979 					astFactory.addASTChild(currentAST, returnAST);
980 				}
981 				else if ((LA(1)==IDENT) && (_tokenSet_5.member(LA(2)))) {
982 				}
983 				else {
984 					throw new NoViableAltException(LT(1), getFilename());
985 				}
986 				
987 				}
988 				AST tmp23_AST = null;
989 				tmp23_AST = astFactory.create(LT(1));
990 				astFactory.addASTChild(currentAST, tmp23_AST);
991 				match(IDENT);
992 				{
993 				if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) {
994 					typeArguments(addImagNode);
995 					astFactory.addASTChild(currentAST, returnAST);
996 				}
997 				else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
998 				}
999 				else {
1000 					throw new NoViableAltException(LT(1), getFilename());
1001 				}
1002 				
1003 				}
1004 			}
1005 			else {
1006 				break _loop25;
1007 			}
1008 			
1009 		} while (true);
1010 		}
1011 		classOrInterfaceType_AST = (AST)currentAST.root;
1012 		returnAST = classOrInterfaceType_AST;
1013 	}
1014 	
1015 	public final void typeArguments(
1016 		boolean addImagNode
1017 	) throws RecognitionException, TokenStreamException {
1018 		
1019 		returnAST = null;
1020 		ASTPair currentAST = new ASTPair();
1021 		AST typeArguments_AST = null;
1022 		Token  lt = null;
1023 		AST lt_AST = null;
1024 		int currentLtLevel = 0;
1025 		
1026 		if ( inputState.guessing==0 ) {
1027 			currentLtLevel = ltCounter;
1028 		}
1029 		lt = LT(1);
1030 		lt_AST = astFactory.create(lt);
1031 		astFactory.addASTChild(currentAST, lt_AST);
1032 		match(LT);
1033 		if ( inputState.guessing==0 ) {
1034 			lt_AST.setType(GENERIC_START); ;ltCounter++;
1035 		}
1036 		{
1037 		if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
1038 			typeArgument(addImagNode);
1039 			astFactory.addASTChild(currentAST, returnAST);
1040 			{
1041 			_loop37:
1042 			do {
1043 				if (((LA(1)==COMMA) && (_tokenSet_7.member(LA(2))))&&(gtToReconcile == 0)) {
1044 					AST tmp24_AST = null;
1045 					tmp24_AST = astFactory.create(LT(1));
1046 					astFactory.addASTChild(currentAST, tmp24_AST);
1047 					match(COMMA);
1048 					typeArgument(addImagNode);
1049 					astFactory.addASTChild(currentAST, returnAST);
1050 				}
1051 				else {
1052 					break _loop37;
1053 				}
1054 				
1055 			} while (true);
1056 			}
1057 		}
1058 		else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
1059 		}
1060 		else {
1061 			throw new NoViableAltException(LT(1), getFilename());
1062 		}
1063 		
1064 		}
1065 		{
1066 		if ((_tokenSet_8.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
1067 			typeArgumentsOrParametersEnd();
1068 			astFactory.addASTChild(currentAST, returnAST);
1069 		}
1070 		else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
1071 		}
1072 		else {
1073 			throw new NoViableAltException(LT(1), getFilename());
1074 		}
1075 		
1076 		}
1077 		if ( inputState.guessing==0 ) {
1078 			
1079 			if (areThereGtsToEmit())
1080 			{
1081 			astFactory.addASTChild(currentAST, emitSingleGt());
1082 			}
1083 			
1084 		}
1085 		if (!(areLtsAndGtsBalanced(currentLtLevel)))
1086 		  throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)");
1087 		if ( inputState.guessing==0 ) {
1088 			typeArguments_AST = (AST)currentAST.root;
1089 			typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS")).add(typeArguments_AST));
1090 			currentAST.root = typeArguments_AST;
1091 			currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ?
1092 				typeArguments_AST.getFirstChild() : typeArguments_AST;
1093 			currentAST.advanceChildToEnd();
1094 		}
1095 		typeArguments_AST = (AST)currentAST.root;
1096 		returnAST = typeArguments_AST;
1097 	}
1098 	
1099 	public final void typeArgument(
1100 		boolean addImagNode
1101 	) throws RecognitionException, TokenStreamException {
1102 		
1103 		returnAST = null;
1104 		ASTPair currentAST = new ASTPair();
1105 		AST typeArgument_AST = null;
1106 		
1107 		{
1108 		{
1109 		if (((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) {
1110 			annotations();
1111 			astFactory.addASTChild(currentAST, returnAST);
1112 		}
1113 		else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
1114 		}
1115 		else {
1116 			throw new NoViableAltException(LT(1), getFilename());
1117 		}
1118 		
1119 		}
1120 		{
1121 		switch ( LA(1)) {
1122 		case IDENT:
1123 		case AT:
1124 		{
1125 			classTypeSpec(addImagNode);
1126 			astFactory.addASTChild(currentAST, returnAST);
1127 			break;
1128 		}
1129 		case LITERAL_void:
1130 		case LITERAL_boolean:
1131 		case LITERAL_byte:
1132 		case LITERAL_char:
1133 		case LITERAL_short:
1134 		case LITERAL_int:
1135 		case LITERAL_float:
1136 		case LITERAL_long:
1137 		case LITERAL_double:
1138 		{
1139 			builtInTypeSpec(addImagNode);
1140 			astFactory.addASTChild(currentAST, returnAST);
1141 			break;
1142 		}
1143 		case QUESTION:
1144 		{
1145 			wildcardType(addImagNode);
1146 			astFactory.addASTChild(currentAST, returnAST);
1147 			break;
1148 		}
1149 		default:
1150 		{
1151 			throw new NoViableAltException(LT(1), getFilename());
1152 		}
1153 		}
1154 		}
1155 		}
1156 		if ( inputState.guessing==0 ) {
1157 			typeArgument_AST = (AST)currentAST.root;
1158 			typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENT,"TYPE_ARGUMENT")).add(typeArgument_AST));
1159 			currentAST.root = typeArgument_AST;
1160 			currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ?
1161 				typeArgument_AST.getFirstChild() : typeArgument_AST;
1162 			currentAST.advanceChildToEnd();
1163 		}
1164 		typeArgument_AST = (AST)currentAST.root;
1165 		returnAST = typeArgument_AST;
1166 	}
1167 	
1168 	public final void wildcardType(
1169 		boolean addImagNode
1170 	) throws RecognitionException, TokenStreamException {
1171 		
1172 		returnAST = null;
1173 		ASTPair currentAST = new ASTPair();
1174 		AST wildcardType_AST = null;
1175 		Token  q = null;
1176 		AST q_AST = null;
1177 		
1178 		q = LT(1);
1179 		q_AST = astFactory.create(q);
1180 		astFactory.addASTChild(currentAST, q_AST);
1181 		match(QUESTION);
1182 		if ( inputState.guessing==0 ) {
1183 			q_AST.setType(WILDCARD_TYPE);
1184 		}
1185 		{
1186 		boolean synPredMatched33 = false;
1187 		if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (_tokenSet_9.member(LA(2))))) {
1188 			int _m33 = mark();
1189 			synPredMatched33 = true;
1190 			inputState.guessing++;
1191 			try {
1192 				{
1193 				switch ( LA(1)) {
1194 				case LITERAL_extends:
1195 				{
1196 					match(LITERAL_extends);
1197 					break;
1198 				}
1199 				case LITERAL_super:
1200 				{
1201 					match(LITERAL_super);
1202 					break;
1203 				}
1204 				default:
1205 				{
1206 					throw new NoViableAltException(LT(1), getFilename());
1207 				}
1208 				}
1209 				}
1210 			}
1211 			catch (RecognitionException pe) {
1212 				synPredMatched33 = false;
1213 			}
1214 			rewind(_m33);
1215 inputState.guessing--;
1216 		}
1217 		if ( synPredMatched33 ) {
1218 			typeArgumentBounds(addImagNode);
1219 			astFactory.addASTChild(currentAST, returnAST);
1220 		}
1221 		else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
1222 		}
1223 		else {
1224 			throw new NoViableAltException(LT(1), getFilename());
1225 		}
1226 		
1227 		}
1228 		wildcardType_AST = (AST)currentAST.root;
1229 		returnAST = wildcardType_AST;
1230 	}
1231 	
1232 	public final void typeArgumentBounds(
1233 		boolean addImagNode
1234 	) throws RecognitionException, TokenStreamException {
1235 		
1236 		returnAST = null;
1237 		ASTPair currentAST = new ASTPair();
1238 		AST typeArgumentBounds_AST = null;
1239 		Token  e = null;
1240 		AST e_AST = null;
1241 		Token  s = null;
1242 		AST s_AST = null;
1243 		Token  lb = null;
1244 		AST lb_AST = null;
1245 		
1246 		{
1247 		switch ( LA(1)) {
1248 		case LITERAL_extends:
1249 		{
1250 			e = LT(1);
1251 			e_AST = astFactory.create(e);
1252 			astFactory.makeASTRoot(currentAST, e_AST);
1253 			match(LITERAL_extends);
1254 			if ( inputState.guessing==0 ) {
1255 				e_AST.setType(TYPE_UPPER_BOUNDS);
1256 			}
1257 			break;
1258 		}
1259 		case LITERAL_super:
1260 		{
1261 			s = LT(1);
1262 			s_AST = astFactory.create(s);
1263 			astFactory.makeASTRoot(currentAST, s_AST);
1264 			match(LITERAL_super);
1265 			if ( inputState.guessing==0 ) {
1266 				s_AST.setType(TYPE_LOWER_BOUNDS);
1267 			}
1268 			break;
1269 		}
1270 		default:
1271 		{
1272 			throw new NoViableAltException(LT(1), getFilename());
1273 		}
1274 		}
1275 		}
1276 		{
1277 		switch ( LA(1)) {
1278 		case IDENT:
1279 		case AT:
1280 		{
1281 			classOrInterfaceType(addImagNode);
1282 			astFactory.addASTChild(currentAST, returnAST);
1283 			break;
1284 		}
1285 		case LITERAL_void:
1286 		case LITERAL_boolean:
1287 		case LITERAL_byte:
1288 		case LITERAL_char:
1289 		case LITERAL_short:
1290 		case LITERAL_int:
1291 		case LITERAL_float:
1292 		case LITERAL_long:
1293 		case LITERAL_double:
1294 		{
1295 			builtInType();
1296 			astFactory.addASTChild(currentAST, returnAST);
1297 			break;
1298 		}
1299 		default:
1300 		{
1301 			throw new NoViableAltException(LT(1), getFilename());
1302 		}
1303 		}
1304 		}
1305 		{
1306 		_loop44:
1307 		do {
1308 			if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
1309 				lb = LT(1);
1310 				lb_AST = astFactory.create(lb);
1311 				astFactory.makeASTRoot(currentAST, lb_AST);
1312 				match(LBRACK);
1313 				if ( inputState.guessing==0 ) {
1314 					lb_AST.setType(ARRAY_DECLARATOR);
1315 				}
1316 				AST tmp25_AST = null;
1317 				tmp25_AST = astFactory.create(LT(1));
1318 				astFactory.addASTChild(currentAST, tmp25_AST);
1319 				match(RBRACK);
1320 			}
1321 			else {
1322 				break _loop44;
1323 			}
1324 			
1325 		} while (true);
1326 		}
1327 		typeArgumentBounds_AST = (AST)currentAST.root;
1328 		returnAST = typeArgumentBounds_AST;
1329 	}
1330 	
1331 	protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException {
1332 		
1333 		returnAST = null;
1334 		ASTPair currentAST = new ASTPair();
1335 		AST typeArgumentsOrParametersEnd_AST = null;
1336 		Token  g = null;
1337 		AST g_AST = null;
1338 		Token  sr = null;
1339 		AST sr_AST = null;
1340 		Token  bsr = null;
1341 		AST bsr_AST = null;
1342 		
1343 		switch ( LA(1)) {
1344 		case GT:
1345 		{
1346 			g = LT(1);
1347 			g_AST = astFactory.create(g);
1348 			match(GT);
1349 			if ( inputState.guessing==0 ) {
1350 				consumeCurrentGtSequence((DetailAST)g_AST);
1351 			}
1352 			break;
1353 		}
1354 		case SR:
1355 		{
1356 			sr = LT(1);
1357 			sr_AST = astFactory.create(sr);
1358 			match(SR);
1359 			if ( inputState.guessing==0 ) {
1360 				consumeCurrentGtSequence((DetailAST)sr_AST);
1361 			}
1362 			break;
1363 		}
1364 		case BSR:
1365 		{
1366 			bsr = LT(1);
1367 			bsr_AST = astFactory.create(bsr);
1368 			match(BSR);
1369 			if ( inputState.guessing==0 ) {
1370 				consumeCurrentGtSequence((DetailAST)bsr_AST);
1371 			}
1372 			break;
1373 		}
1374 		default:
1375 		{
1376 			throw new NoViableAltException(LT(1), getFilename());
1377 		}
1378 		}
1379 		returnAST = typeArgumentsOrParametersEnd_AST;
1380 	}
1381 	
1382 	public final void builtInType() throws RecognitionException, TokenStreamException {
1383 		
1384 		returnAST = null;
1385 		ASTPair currentAST = new ASTPair();
1386 		AST builtInType_AST = null;
1387 		
1388 		switch ( LA(1)) {
1389 		case LITERAL_void:
1390 		{
1391 			AST tmp26_AST = null;
1392 			tmp26_AST = astFactory.create(LT(1));
1393 			astFactory.addASTChild(currentAST, tmp26_AST);
1394 			match(LITERAL_void);
1395 			builtInType_AST = (AST)currentAST.root;
1396 			break;
1397 		}
1398 		case LITERAL_boolean:
1399 		{
1400 			AST tmp27_AST = null;
1401 			tmp27_AST = astFactory.create(LT(1));
1402 			astFactory.addASTChild(currentAST, tmp27_AST);
1403 			match(LITERAL_boolean);
1404 			builtInType_AST = (AST)currentAST.root;
1405 			break;
1406 		}
1407 		case LITERAL_byte:
1408 		{
1409 			AST tmp28_AST = null;
1410 			tmp28_AST = astFactory.create(LT(1));
1411 			astFactory.addASTChild(currentAST, tmp28_AST);
1412 			match(LITERAL_byte);
1413 			builtInType_AST = (AST)currentAST.root;
1414 			break;
1415 		}
1416 		case LITERAL_char:
1417 		{
1418 			AST tmp29_AST = null;
1419 			tmp29_AST = astFactory.create(LT(1));
1420 			astFactory.addASTChild(currentAST, tmp29_AST);
1421 			match(LITERAL_char);
1422 			builtInType_AST = (AST)currentAST.root;
1423 			break;
1424 		}
1425 		case LITERAL_short:
1426 		{
1427 			AST tmp30_AST = null;
1428 			tmp30_AST = astFactory.create(LT(1));
1429 			astFactory.addASTChild(currentAST, tmp30_AST);
1430 			match(LITERAL_short);
1431 			builtInType_AST = (AST)currentAST.root;
1432 			break;
1433 		}
1434 		case LITERAL_int:
1435 		{
1436 			AST tmp31_AST = null;
1437 			tmp31_AST = astFactory.create(LT(1));
1438 			astFactory.addASTChild(currentAST, tmp31_AST);
1439 			match(LITERAL_int);
1440 			builtInType_AST = (AST)currentAST.root;
1441 			break;
1442 		}
1443 		case LITERAL_float:
1444 		{
1445 			AST tmp32_AST = null;
1446 			tmp32_AST = astFactory.create(LT(1));
1447 			astFactory.addASTChild(currentAST, tmp32_AST);
1448 			match(LITERAL_float);
1449 			builtInType_AST = (AST)currentAST.root;
1450 			break;
1451 		}
1452 		case LITERAL_long:
1453 		{
1454 			AST tmp33_AST = null;
1455 			tmp33_AST = astFactory.create(LT(1));
1456 			astFactory.addASTChild(currentAST, tmp33_AST);
1457 			match(LITERAL_long);
1458 			builtInType_AST = (AST)currentAST.root;
1459 			break;
1460 		}
1461 		case LITERAL_double:
1462 		{
1463 			AST tmp34_AST = null;
1464 			tmp34_AST = astFactory.create(LT(1));
1465 			astFactory.addASTChild(currentAST, tmp34_AST);
1466 			match(LITERAL_double);
1467 			builtInType_AST = (AST)currentAST.root;
1468 			break;
1469 		}
1470 		default:
1471 		{
1472 			throw new NoViableAltException(LT(1), getFilename());
1473 		}
1474 		}
1475 		returnAST = builtInType_AST;
1476 	}
1477 	
1478 	public final void type() throws RecognitionException, TokenStreamException {
1479 		
1480 		returnAST = null;
1481 		ASTPair currentAST = new ASTPair();
1482 		AST type_AST = null;
1483 		
1484 		switch ( LA(1)) {
1485 		case IDENT:
1486 		case AT:
1487 		{
1488 			classOrInterfaceType(false);
1489 			astFactory.addASTChild(currentAST, returnAST);
1490 			type_AST = (AST)currentAST.root;
1491 			break;
1492 		}
1493 		case LITERAL_void:
1494 		case LITERAL_boolean:
1495 		case LITERAL_byte:
1496 		case LITERAL_char:
1497 		case LITERAL_short:
1498 		case LITERAL_int:
1499 		case LITERAL_float:
1500 		case LITERAL_long:
1501 		case LITERAL_double:
1502 		{
1503 			builtInType();
1504 			astFactory.addASTChild(currentAST, returnAST);
1505 			type_AST = (AST)currentAST.root;
1506 			break;
1507 		}
1508 		default:
1509 		{
1510 			throw new NoViableAltException(LT(1), getFilename());
1511 		}
1512 		}
1513 		returnAST = type_AST;
1514 	}
1515 	
1516 /** A declaration is the creation of a reference or primitive-type variable
1517  *  Create a separate Type/Var tree for each var in the var list.
1518     @throws RecognitionException if recognition problem occurs.
1519     @throws TokenStreamException if problem occurs while generating a stream of tokens.
1520  */
1521 	public final void declaration() throws RecognitionException, TokenStreamException {
1522 		
1523 		returnAST = null;
1524 		ASTPair currentAST = new ASTPair();
1525 		AST declaration_AST = null;
1526 		AST m_AST = null;
1527 		AST t_AST = null;
1528 		AST v_AST = null;
1529 		
1530 		modifiers();
1531 		m_AST = (AST)returnAST;
1532 		typeSpec(false);
1533 		t_AST = (AST)returnAST;
1534 		variableDefinitions(m_AST,t_AST);
1535 		v_AST = (AST)returnAST;
1536 		if ( inputState.guessing==0 ) {
1537 			declaration_AST = (AST)currentAST.root;
1538 			declaration_AST = v_AST;
1539 			currentAST.root = declaration_AST;
1540 			currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
1541 				declaration_AST.getFirstChild() : declaration_AST;
1542 			currentAST.advanceChildToEnd();
1543 		}
1544 		returnAST = declaration_AST;
1545 	}
1546 	
1547 	public final void variableDefinitions(
1548 		AST mods, AST t
1549 	) throws RecognitionException, TokenStreamException {
1550 		
1551 		returnAST = null;
1552 		ASTPair currentAST = new ASTPair();
1553 		AST variableDefinitions_AST = null;
1554 		
1555 		variableDeclarator((AST) getASTFactory().dupTree(mods),
1556                            //dupList as this also copies siblings (like TYPE_ARGUMENTS)
1557                            (AST) getASTFactory().dupList(t));
1558 		astFactory.addASTChild(currentAST, returnAST);
1559 		{
1560 		_loop165:
1561 		do {
1562 			if ((LA(1)==COMMA)) {
1563 				AST tmp35_AST = null;
1564 				tmp35_AST = astFactory.create(LT(1));
1565 				astFactory.addASTChild(currentAST, tmp35_AST);
1566 				match(COMMA);
1567 				variableDeclarator((AST) getASTFactory().dupTree(mods),
1568                                //dupList as this also copies siblings (like TYPE_ARGUMENTS)
1569                                (AST) getASTFactory().dupList(t));
1570 				astFactory.addASTChild(currentAST, returnAST);
1571 			}
1572 			else {
1573 				break _loop165;
1574 			}
1575 			
1576 		} while (true);
1577 		}
1578 		variableDefinitions_AST = (AST)currentAST.root;
1579 		returnAST = variableDefinitions_AST;
1580 	}
1581 	
1582 	public final void modifier() throws RecognitionException, TokenStreamException {
1583 		
1584 		returnAST = null;
1585 		ASTPair currentAST = new ASTPair();
1586 		AST modifier_AST = null;
1587 		
1588 		switch ( LA(1)) {
1589 		case LITERAL_private:
1590 		{
1591 			AST tmp36_AST = null;
1592 			tmp36_AST = astFactory.create(LT(1));
1593 			astFactory.addASTChild(currentAST, tmp36_AST);
1594 			match(LITERAL_private);
1595 			modifier_AST = (AST)currentAST.root;
1596 			break;
1597 		}
1598 		case LITERAL_public:
1599 		{
1600 			AST tmp37_AST = null;
1601 			tmp37_AST = astFactory.create(LT(1));
1602 			astFactory.addASTChild(currentAST, tmp37_AST);
1603 			match(LITERAL_public);
1604 			modifier_AST = (AST)currentAST.root;
1605 			break;
1606 		}
1607 		case LITERAL_protected:
1608 		{
1609 			AST tmp38_AST = null;
1610 			tmp38_AST = astFactory.create(LT(1));
1611 			astFactory.addASTChild(currentAST, tmp38_AST);
1612 			match(LITERAL_protected);
1613 			modifier_AST = (AST)currentAST.root;
1614 			break;
1615 		}
1616 		case LITERAL_static:
1617 		{
1618 			AST tmp39_AST = null;
1619 			tmp39_AST = astFactory.create(LT(1));
1620 			astFactory.addASTChild(currentAST, tmp39_AST);
1621 			match(LITERAL_static);
1622 			modifier_AST = (AST)currentAST.root;
1623 			break;
1624 		}
1625 		case LITERAL_transient:
1626 		{
1627 			AST tmp40_AST = null;
1628 			tmp40_AST = astFactory.create(LT(1));
1629 			astFactory.addASTChild(currentAST, tmp40_AST);
1630 			match(LITERAL_transient);
1631 			modifier_AST = (AST)currentAST.root;
1632 			break;
1633 		}
1634 		case FINAL:
1635 		{
1636 			AST tmp41_AST = null;
1637 			tmp41_AST = astFactory.create(LT(1));
1638 			astFactory.addASTChild(currentAST, tmp41_AST);
1639 			match(FINAL);
1640 			modifier_AST = (AST)currentAST.root;
1641 			break;
1642 		}
1643 		case ABSTRACT:
1644 		{
1645 			AST tmp42_AST = null;
1646 			tmp42_AST = astFactory.create(LT(1));
1647 			astFactory.addASTChild(currentAST, tmp42_AST);
1648 			match(ABSTRACT);
1649 			modifier_AST = (AST)currentAST.root;
1650 			break;
1651 		}
1652 		case LITERAL_native:
1653 		{
1654 			AST tmp43_AST = null;
1655 			tmp43_AST = astFactory.create(LT(1));
1656 			astFactory.addASTChild(currentAST, tmp43_AST);
1657 			match(LITERAL_native);
1658 			modifier_AST = (AST)currentAST.root;
1659 			break;
1660 		}
1661 		case LITERAL_synchronized:
1662 		{
1663 			AST tmp44_AST = null;
1664 			tmp44_AST = astFactory.create(LT(1));
1665 			astFactory.addASTChild(currentAST, tmp44_AST);
1666 			match(LITERAL_synchronized);
1667 			modifier_AST = (AST)currentAST.root;
1668 			break;
1669 		}
1670 		case LITERAL_volatile:
1671 		{
1672 			AST tmp45_AST = null;
1673 			tmp45_AST = astFactory.create(LT(1));
1674 			astFactory.addASTChild(currentAST, tmp45_AST);
1675 			match(LITERAL_volatile);
1676 			modifier_AST = (AST)currentAST.root;
1677 			break;
1678 		}
1679 		case STRICTFP:
1680 		{
1681 			AST tmp46_AST = null;
1682 			tmp46_AST = astFactory.create(LT(1));
1683 			astFactory.addASTChild(currentAST, tmp46_AST);
1684 			match(STRICTFP);
1685 			modifier_AST = (AST)currentAST.root;
1686 			break;
1687 		}
1688 		case LITERAL_default:
1689 		{
1690 			AST tmp47_AST = null;
1691 			tmp47_AST = astFactory.create(LT(1));
1692 			astFactory.addASTChild(currentAST, tmp47_AST);
1693 			match(LITERAL_default);
1694 			modifier_AST = (AST)currentAST.root;
1695 			break;
1696 		}
1697 		default:
1698 		{
1699 			throw new NoViableAltException(LT(1), getFilename());
1700 		}
1701 		}
1702 		returnAST = modifier_AST;
1703 	}
1704 	
1705 	public final void annotation() throws RecognitionException, TokenStreamException {
1706 		
1707 		returnAST = null;
1708 		ASTPair currentAST = new ASTPair();
1709 		AST annotation_AST = null;
1710 		AST i_AST = null;
1711 		Token  l = null;
1712 		AST l_AST = null;
1713 		AST args_AST = null;
1714 		Token  r = null;
1715 		AST r_AST = null;
1716 		
1717 		AST tmp48_AST = null;
1718 		tmp48_AST = astFactory.create(LT(1));
1719 		match(AT);
1720 		identifier();
1721 		i_AST = (AST)returnAST;
1722 		{
1723 		switch ( LA(1)) {
1724 		case LPAREN:
1725 		{
1726 			l = LT(1);
1727 			l_AST = astFactory.create(l);
1728 			match(LPAREN);
1729 			{
1730 			switch ( LA(1)) {
1731 			case LITERAL_void:
1732 			case LITERAL_boolean:
1733 			case LITERAL_byte:
1734 			case LITERAL_char:
1735 			case LITERAL_short:
1736 			case LITERAL_int:
1737 			case LITERAL_float:
1738 			case LITERAL_long:
1739 			case LITERAL_double:
1740 			case IDENT:
1741 			case LCURLY:
1742 			case LPAREN:
1743 			case LITERAL_this:
1744 			case LITERAL_super:
1745 			case PLUS:
1746 			case MINUS:
1747 			case INC:
1748 			case DEC:
1749 			case BNOT:
1750 			case LNOT:
1751 			case LITERAL_true:
1752 			case LITERAL_false:
1753 			case LITERAL_null:
1754 			case LITERAL_new:
1755 			case NUM_INT:
1756 			case CHAR_LITERAL:
1757 			case STRING_LITERAL:
1758 			case NUM_FLOAT:
1759 			case NUM_LONG:
1760 			case NUM_DOUBLE:
1761 			case AT:
1762 			{
1763 				annotationArguments();
1764 				args_AST = (AST)returnAST;
1765 				break;
1766 			}
1767 			case RPAREN:
1768 			{
1769 				break;
1770 			}
1771 			default:
1772 			{
1773 				throw new NoViableAltException(LT(1), getFilename());
1774 			}
1775 			}
1776 			}
1777 			r = LT(1);
1778 			r_AST = astFactory.create(r);
1779 			match(RPAREN);
1780 			break;
1781 		}
1782 		case FINAL:
1783 		case ABSTRACT:
1784 		case STRICTFP:
1785 		case LITERAL_package:
1786 		case SEMI:
1787 		case LBRACK:
1788 		case LITERAL_void:
1789 		case LITERAL_boolean:
1790 		case LITERAL_byte:
1791 		case LITERAL_char:
1792 		case LITERAL_short:
1793 		case LITERAL_int:
1794 		case LITERAL_float:
1795 		case LITERAL_long:
1796 		case LITERAL_double:
1797 		case IDENT:
1798 		case LITERAL_private:
1799 		case LITERAL_public:
1800 		case LITERAL_protected:
1801 		case LITERAL_static:
1802 		case LITERAL_transient:
1803 		case LITERAL_native:
1804 		case LITERAL_synchronized:
1805 		case LITERAL_volatile:
1806 		case LITERAL_class:
1807 		case LITERAL_interface:
1808 		case RCURLY:
1809 		case COMMA:
1810 		case RPAREN:
1811 		case LITERAL_this:
1812 		case LITERAL_default:
1813 		case QUESTION:
1814 		case LT:
1815 		case ENUM:
1816 		case AT:
1817 		{
1818 			break;
1819 		}
1820 		default:
1821 		{
1822 			throw new NoViableAltException(LT(1), getFilename());
1823 		}
1824 		}
1825 		}
1826 		if ( inputState.guessing==0 ) {
1827 			annotation_AST = (AST)currentAST.root;
1828 			annotation_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION,"ANNOTATION")).add(tmp48_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST));
1829 			currentAST.root = annotation_AST;
1830 			currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ?
1831 				annotation_AST.getFirstChild() : annotation_AST;
1832 			currentAST.advanceChildToEnd();
1833 		}
1834 		returnAST = annotation_AST;
1835 	}
1836 	
1837 	public final void annotationArguments() throws RecognitionException, TokenStreamException {
1838 		
1839 		returnAST = null;
1840 		ASTPair currentAST = new ASTPair();
1841 		AST annotationArguments_AST = null;
1842 		
1843 		if ((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2)))) {
1844 			annotationMemberValueInitializer();
1845 			astFactory.addASTChild(currentAST, returnAST);
1846 			annotationArguments_AST = (AST)currentAST.root;
1847 		}
1848 		else if ((LA(1)==IDENT) && (LA(2)==ASSIGN)) {
1849 			annotationMemberValuePairs();
1850 			astFactory.addASTChild(currentAST, returnAST);
1851 			annotationArguments_AST = (AST)currentAST.root;
1852 		}
1853 		else {
1854 			throw new NoViableAltException(LT(1), getFilename());
1855 		}
1856 		
1857 		returnAST = annotationArguments_AST;
1858 	}
1859 	
1860 	public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException {
1861 		
1862 		returnAST = null;
1863 		ASTPair currentAST = new ASTPair();
1864 		AST annotationMemberValueInitializer_AST = null;
1865 		
1866 		boolean synPredMatched76 = false;
1867 		if (((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2))))) {
1868 			int _m76 = mark();
1869 			synPredMatched76 = true;
1870 			inputState.guessing++;
1871 			try {
1872 				{
1873 				annotationExpression();
1874 				}
1875 			}
1876 			catch (RecognitionException pe) {
1877 				synPredMatched76 = false;
1878 			}
1879 			rewind(_m76);
1880 inputState.guessing--;
1881 		}
1882 		if ( synPredMatched76 ) {
1883 			annotationExpression();
1884 			astFactory.addASTChild(currentAST, returnAST);
1885 			annotationMemberValueInitializer_AST = (AST)currentAST.root;
1886 		}
1887 		else if ((LA(1)==AT) && (LA(2)==IDENT)) {
1888 			annotation();
1889 			astFactory.addASTChild(currentAST, returnAST);
1890 			annotationMemberValueInitializer_AST = (AST)currentAST.root;
1891 		}
1892 		else if ((LA(1)==LCURLY)) {
1893 			annotationMemberArrayInitializer();
1894 			astFactory.addASTChild(currentAST, returnAST);
1895 			annotationMemberValueInitializer_AST = (AST)currentAST.root;
1896 		}
1897 		else {
1898 			throw new NoViableAltException(LT(1), getFilename());
1899 		}
1900 		
1901 		returnAST = annotationMemberValueInitializer_AST;
1902 	}
1903 	
1904 	public final void annotationMemberValuePairs() throws RecognitionException, TokenStreamException {
1905 		
1906 		returnAST = null;
1907 		ASTPair currentAST = new ASTPair();
1908 		AST annotationMemberValuePairs_AST = null;
1909 		
1910 		annotationMemberValuePair();
1911 		astFactory.addASTChild(currentAST, returnAST);
1912 		{
1913 		_loop72:
1914 		do {
1915 			if ((LA(1)==COMMA)) {
1916 				AST tmp49_AST = null;
1917 				tmp49_AST = astFactory.create(LT(1));
1918 				astFactory.addASTChild(currentAST, tmp49_AST);
1919 				match(COMMA);
1920 				annotationMemberValuePair();
1921 				astFactory.addASTChild(currentAST, returnAST);
1922 			}
1923 			else {
1924 				break _loop72;
1925 			}
1926 			
1927 		} while (true);
1928 		}
1929 		annotationMemberValuePairs_AST = (AST)currentAST.root;
1930 		returnAST = annotationMemberValuePairs_AST;
1931 	}
1932 	
1933 	public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException {
1934 		
1935 		returnAST = null;
1936 		ASTPair currentAST = new ASTPair();
1937 		AST annotationMemberValuePair_AST = null;
1938 		Token  i = null;
1939 		AST i_AST = null;
1940 		Token  a = null;
1941 		AST a_AST = null;
1942 		AST v_AST = null;
1943 		
1944 		i = LT(1);
1945 		i_AST = astFactory.create(i);
1946 		match(IDENT);
1947 		a = LT(1);
1948 		a_AST = astFactory.create(a);
1949 		match(ASSIGN);
1950 		annotationMemberValueInitializer();
1951 		v_AST = (AST)returnAST;
1952 		if ( inputState.guessing==0 ) {
1953 			annotationMemberValuePair_AST = (AST)currentAST.root;
1954 			annotationMemberValuePair_AST =
1955 			(AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR")).add(i_AST).add(a_AST).add(v_AST));
1956 			currentAST.root = annotationMemberValuePair_AST;
1957 			currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ?
1958 				annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST;
1959 			currentAST.advanceChildToEnd();
1960 		}
1961 		returnAST = annotationMemberValuePair_AST;
1962 	}
1963 	
1964 	public final void annotationExpression() throws RecognitionException, TokenStreamException {
1965 		
1966 		returnAST = null;
1967 		ASTPair currentAST = new ASTPair();
1968 		AST annotationExpression_AST = null;
1969 		
1970 		conditionalExpression();
1971 		astFactory.addASTChild(currentAST, returnAST);
1972 		if ( inputState.guessing==0 ) {
1973 			annotationExpression_AST = (AST)currentAST.root;
1974 			annotationExpression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(annotationExpression_AST));
1975 			currentAST.root = annotationExpression_AST;
1976 			currentAST.child = annotationExpression_AST!=null &&annotationExpression_AST.getFirstChild()!=null ?
1977 				annotationExpression_AST.getFirstChild() : annotationExpression_AST;
1978 			currentAST.advanceChildToEnd();
1979 		}
1980 		annotationExpression_AST = (AST)currentAST.root;
1981 		returnAST = annotationExpression_AST;
1982 	}
1983 	
1984 	public final void annotationMemberArrayInitializer() throws RecognitionException, TokenStreamException {
1985 		
1986 		returnAST = null;
1987 		ASTPair currentAST = new ASTPair();
1988 		AST annotationMemberArrayInitializer_AST = null;
1989 		Token  lc = null;
1990 		AST lc_AST = null;
1991 		
1992 		lc = LT(1);
1993 		lc_AST = astFactory.create(lc);
1994 		astFactory.makeASTRoot(currentAST, lc_AST);
1995 		match(LCURLY);
1996 		if ( inputState.guessing==0 ) {
1997 			lc_AST.setType(ANNOTATION_ARRAY_INIT);
1998 		}
1999 		{
2000 		switch ( LA(1)) {
2001 		case LITERAL_void:
2002 		case LITERAL_boolean:
2003 		case LITERAL_byte:
2004 		case LITERAL_char:
2005 		case LITERAL_short:
2006 		case LITERAL_int:
2007 		case LITERAL_float:
2008 		case LITERAL_long:
2009 		case LITERAL_double:
2010 		case IDENT:
2011 		case LPAREN:
2012 		case LITERAL_this:
2013 		case LITERAL_super:
2014 		case PLUS:
2015 		case MINUS:
2016 		case INC:
2017 		case DEC:
2018 		case BNOT:
2019 		case LNOT:
2020 		case LITERAL_true:
2021 		case LITERAL_false:
2022 		case LITERAL_null:
2023 		case LITERAL_new:
2024 		case NUM_INT:
2025 		case CHAR_LITERAL:
2026 		case STRING_LITERAL:
2027 		case NUM_FLOAT:
2028 		case NUM_LONG:
2029 		case NUM_DOUBLE:
2030 		case AT:
2031 		{
2032 			annotationMemberArrayValueInitializer();
2033 			astFactory.addASTChild(currentAST, returnAST);
2034 			{
2035 			_loop80:
2036 			do {
2037 				if ((LA(1)==COMMA) && (_tokenSet_12.member(LA(2)))) {
2038 					AST tmp50_AST = null;
2039 					tmp50_AST = astFactory.create(LT(1));
2040 					astFactory.addASTChild(currentAST, tmp50_AST);
2041 					match(COMMA);
2042 					annotationMemberArrayValueInitializer();
2043 					astFactory.addASTChild(currentAST, returnAST);
2044 				}
2045 				else {
2046 					break _loop80;
2047 				}
2048 				
2049 			} while (true);
2050 			}
2051 			{
2052 			switch ( LA(1)) {
2053 			case COMMA:
2054 			{
2055 				AST tmp51_AST = null;
2056 				tmp51_AST = astFactory.create(LT(1));
2057 				astFactory.addASTChild(currentAST, tmp51_AST);
2058 				match(COMMA);
2059 				break;
2060 			}
2061 			case RCURLY:
2062 			{
2063 				break;
2064 			}
2065 			default:
2066 			{
2067 				throw new NoViableAltException(LT(1), getFilename());
2068 			}
2069 			}
2070 			}
2071 			break;
2072 		}
2073 		case RCURLY:
2074 		{
2075 			break;
2076 		}
2077 		default:
2078 		{
2079 			throw new NoViableAltException(LT(1), getFilename());
2080 		}
2081 		}
2082 		}
2083 		AST tmp52_AST = null;
2084 		tmp52_AST = astFactory.create(LT(1));
2085 		astFactory.addASTChild(currentAST, tmp52_AST);
2086 		match(RCURLY);
2087 		annotationMemberArrayInitializer_AST = (AST)currentAST.root;
2088 		returnAST = annotationMemberArrayInitializer_AST;
2089 	}
2090 	
2091 	public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException {
2092 		
2093 		returnAST = null;
2094 		ASTPair currentAST = new ASTPair();
2095 		AST annotationMemberArrayValueInitializer_AST = null;
2096 		
2097 		boolean synPredMatched84 = false;
2098 		if (((_tokenSet_12.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
2099 			int _m84 = mark();
2100 			synPredMatched84 = true;
2101 			inputState.guessing++;
2102 			try {
2103 				{
2104 				annotationExpression();
2105 				}
2106 			}
2107 			catch (RecognitionException pe) {
2108 				synPredMatched84 = false;
2109 			}
2110 			rewind(_m84);
2111 inputState.guessing--;
2112 		}
2113 		if ( synPredMatched84 ) {
2114 			annotationExpression();
2115 			astFactory.addASTChild(currentAST, returnAST);
2116 			annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
2117 		}
2118 		else if ((LA(1)==AT) && (LA(2)==IDENT)) {
2119 			annotation();
2120 			astFactory.addASTChild(currentAST, returnAST);
2121 			annotationMemberArrayValueInitializer_AST = (AST)currentAST.root;
2122 		}
2123 		else {
2124 			throw new NoViableAltException(LT(1), getFilename());
2125 		}
2126 		
2127 		returnAST = annotationMemberArrayValueInitializer_AST;
2128 	}
2129 	
2130 	public final void conditionalExpression() throws RecognitionException, TokenStreamException {
2131 		
2132 		returnAST = null;
2133 		ASTPair currentAST = new ASTPair();
2134 		AST conditionalExpression_AST = null;
2135 		
2136 		logicalOrExpression();
2137 		astFactory.addASTChild(currentAST, returnAST);
2138 		{
2139 		switch ( LA(1)) {
2140 		case QUESTION:
2141 		{
2142 			AST tmp53_AST = null;
2143 			tmp53_AST = astFactory.create(LT(1));
2144 			astFactory.makeASTRoot(currentAST, tmp53_AST);
2145 			match(QUESTION);
2146 			{
2147 			boolean synPredMatched284 = false;
2148 			if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
2149 				int _m284 = mark();
2150 				synPredMatched284 = true;
2151 				inputState.guessing++;
2152 				try {
2153 					{
2154 					lambdaExpression();
2155 					}
2156 				}
2157 				catch (RecognitionException pe) {
2158 					synPredMatched284 = false;
2159 				}
2160 				rewind(_m284);
2161 inputState.guessing--;
2162 			}
2163 			if ( synPredMatched284 ) {
2164 				lambdaExpression();
2165 				astFactory.addASTChild(currentAST, returnAST);
2166 			}
2167 			else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
2168 				assignmentExpression();
2169 				astFactory.addASTChild(currentAST, returnAST);
2170 			}
2171 			else {
2172 				throw new NoViableAltException(LT(1), getFilename());
2173 			}
2174 			
2175 			}
2176 			AST tmp54_AST = null;
2177 			tmp54_AST = astFactory.create(LT(1));
2178 			astFactory.addASTChild(currentAST, tmp54_AST);
2179 			match(COLON);
2180 			{
2181 			boolean synPredMatched287 = false;
2182 			if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
2183 				int _m287 = mark();
2184 				synPredMatched287 = true;
2185 				inputState.guessing++;
2186 				try {
2187 					{
2188 					lambdaExpression();
2189 					}
2190 				}
2191 				catch (RecognitionException pe) {
2192 					synPredMatched287 = false;
2193 				}
2194 				rewind(_m287);
2195 inputState.guessing--;
2196 			}
2197 			if ( synPredMatched287 ) {
2198 				lambdaExpression();
2199 				astFactory.addASTChild(currentAST, returnAST);
2200 			}
2201 			else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {
2202 				conditionalExpression();
2203 				astFactory.addASTChild(currentAST, returnAST);
2204 			}
2205 			else {
2206 				throw new NoViableAltException(LT(1), getFilename());
2207 			}
2208 			
2209 			}
2210 			break;
2211 		}
2212 		case FINAL:
2213 		case ABSTRACT:
2214 		case STRICTFP:
2215 		case SEMI:
2216 		case RBRACK:
2217 		case LITERAL_void:
2218 		case LITERAL_boolean:
2219 		case LITERAL_byte:
2220 		case LITERAL_char:
2221 		case LITERAL_short:
2222 		case LITERAL_int:
2223 		case LITERAL_float:
2224 		case LITERAL_long:
2225 		case LITERAL_double:
2226 		case IDENT:
2227 		case STAR:
2228 		case LITERAL_private:
2229 		case LITERAL_public:
2230 		case LITERAL_protected:
2231 		case LITERAL_static:
2232 		case LITERAL_transient:
2233 		case LITERAL_native:
2234 		case LITERAL_synchronized:
2235 		case LITERAL_volatile:
2236 		case LITERAL_class:
2237 		case LITERAL_interface:
2238 		case LCURLY:
2239 		case RCURLY:
2240 		case COMMA:
2241 		case LPAREN:
2242 		case RPAREN:
2243 		case LITERAL_this:
2244 		case LITERAL_super:
2245 		case ASSIGN:
2246 		case COLON:
2247 		case LITERAL_if:
2248 		case LITERAL_while:
2249 		case LITERAL_do:
2250 		case LITERAL_break:
2251 		case LITERAL_continue:
2252 		case LITERAL_return:
2253 		case LITERAL_switch:
2254 		case LITERAL_throw:
2255 		case LITERAL_for:
2256 		case LITERAL_else:
2257 		case LITERAL_case:
2258 		case LITERAL_default:
2259 		case LITERAL_try:
2260 		case PLUS_ASSIGN:
2261 		case MINUS_ASSIGN:
2262 		case STAR_ASSIGN:
2263 		case DIV_ASSIGN:
2264 		case MOD_ASSIGN:
2265 		case SR_ASSIGN:
2266 		case BSR_ASSIGN:
2267 		case SL_ASSIGN:
2268 		case BAND_ASSIGN:
2269 		case BXOR_ASSIGN:
2270 		case BOR_ASSIGN:
2271 		case LT:
2272 		case GT:
2273 		case LE:
2274 		case GE:
2275 		case LITERAL_instanceof:
2276 		case SL:
2277 		case SR:
2278 		case BSR:
2279 		case PLUS:
2280 		case MINUS:
2281 		case DIV:
2282 		case MOD:
2283 		case INC:
2284 		case DEC:
2285 		case BNOT:
2286 		case LNOT:
2287 		case LITERAL_true:
2288 		case LITERAL_false:
2289 		case LITERAL_null:
2290 		case LITERAL_new:
2291 		case NUM_INT:
2292 		case CHAR_LITERAL:
2293 		case STRING_LITERAL:
2294 		case NUM_FLOAT:
2295 		case NUM_LONG:
2296 		case NUM_DOUBLE:
2297 		case ASSERT:
2298 		case ENUM:
2299 		case AT:
2300 		{
2301 			break;
2302 		}
2303 		default:
2304 		{
2305 			throw new NoViableAltException(LT(1), getFilename());
2306 		}
2307 		}
2308 		}
2309 		conditionalExpression_AST = (AST)currentAST.root;
2310 		returnAST = conditionalExpression_AST;
2311 	}
2312 	
2313 	public final void typeParameters() throws RecognitionException, TokenStreamException {
2314 		
2315 		returnAST = null;
2316 		ASTPair currentAST = new ASTPair();
2317 		AST typeParameters_AST = null;
2318 		Token  lt = null;
2319 		AST lt_AST = null;
2320 		int currentLtLevel = 0;
2321 		
2322 		if ( inputState.guessing==0 ) {
2323 			currentLtLevel = ltCounter;
2324 		}
2325 		lt = LT(1);
2326 		lt_AST = astFactory.create(lt);
2327 		astFactory.addASTChild(currentAST, lt_AST);
2328 		match(LT);
2329 		if ( inputState.guessing==0 ) {
2330 			lt_AST.setType(GENERIC_START); ltCounter++;
2331 		}
2332 		typeParameter();
2333 		astFactory.addASTChild(currentAST, returnAST);
2334 		{
2335 		_loop96:
2336 		do {
2337 			if ((LA(1)==COMMA)) {
2338 				AST tmp55_AST = null;
2339 				tmp55_AST = astFactory.create(LT(1));
2340 				astFactory.addASTChild(currentAST, tmp55_AST);
2341 				match(COMMA);
2342 				typeParameter();
2343 				astFactory.addASTChild(currentAST, returnAST);
2344 			}
2345 			else {
2346 				break _loop96;
2347 			}
2348 			
2349 		} while (true);
2350 		}
2351 		{
2352 		switch ( LA(1)) {
2353 		case GT:
2354 		case SR:
2355 		case BSR:
2356 		{
2357 			typeArgumentsOrParametersEnd();
2358 			astFactory.addASTChild(currentAST, returnAST);
2359 			break;
2360 		}
2361 		case LITERAL_void:
2362 		case LITERAL_boolean:
2363 		case LITERAL_byte:
2364 		case LITERAL_char:
2365 		case LITERAL_short:
2366 		case LITERAL_int:
2367 		case LITERAL_float:
2368 		case LITERAL_long:
2369 		case LITERAL_double:
2370 		case IDENT:
2371 		case LITERAL_extends:
2372 		case LCURLY:
2373 		case LITERAL_implements:
2374 		case AT:
2375 		{
2376 			break;
2377 		}
2378 		default:
2379 		{
2380 			throw new NoViableAltException(LT(1), getFilename());
2381 		}
2382 		}
2383 		}
2384 		if ( inputState.guessing==0 ) {
2385 			
2386 			if (isThereASingleGtToEmit()) {
2387 			astFactory.addASTChild(currentAST, emitSingleGt());
2388 			}
2389 			
2390 		}
2391 		if (!(areLtsAndGtsBalanced(currentLtLevel)))
2392 		  throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)");
2393 		if ( inputState.guessing==0 ) {
2394 			typeParameters_AST = (AST)currentAST.root;
2395 			typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETERS,"TYPE_PARAMETERS")).add(typeParameters_AST));
2396 			currentAST.root = typeParameters_AST;
2397 			currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ?
2398 				typeParameters_AST.getFirstChild() : typeParameters_AST;
2399 			currentAST.advanceChildToEnd();
2400 		}
2401 		typeParameters_AST = (AST)currentAST.root;
2402 		returnAST = typeParameters_AST;
2403 	}
2404 	
2405 	public final void superClassClause() throws RecognitionException, TokenStreamException {
2406 		
2407 		returnAST = null;
2408 		ASTPair currentAST = new ASTPair();
2409 		AST superClassClause_AST = null;
2410 		Token  e = null;
2411 		AST e_AST = null;
2412 		AST c_AST = null;
2413 		
2414 		{
2415 		switch ( LA(1)) {
2416 		case LITERAL_extends:
2417 		{
2418 			e = LT(1);
2419 			e_AST = astFactory.create(e);
2420 			astFactory.makeASTRoot(currentAST, e_AST);
2421 			match(LITERAL_extends);
2422 			if ( inputState.guessing==0 ) {
2423 				e_AST.setType(EXTENDS_CLAUSE);
2424 			}
2425 			classOrInterfaceType(false);
2426 			c_AST = (AST)returnAST;
2427 			astFactory.addASTChild(currentAST, returnAST);
2428 			break;
2429 		}
2430 		case LCURLY:
2431 		case LITERAL_implements:
2432 		{
2433 			break;
2434 		}
2435 		default:
2436 		{
2437 			throw new NoViableAltException(LT(1), getFilename());
2438 		}
2439 		}
2440 		}
2441 		superClassClause_AST = (AST)currentAST.root;
2442 		returnAST = superClassClause_AST;
2443 	}
2444 	
2445 	public final void implementsClause() throws RecognitionException, TokenStreamException {
2446 		
2447 		returnAST = null;
2448 		ASTPair currentAST = new ASTPair();
2449 		AST implementsClause_AST = null;
2450 		Token  i = null;
2451 		AST i_AST = null;
2452 		
2453 		{
2454 		switch ( LA(1)) {
2455 		case LITERAL_implements:
2456 		{
2457 			i = LT(1);
2458 			i_AST = astFactory.create(i);
2459 			astFactory.makeASTRoot(currentAST, i_AST);
2460 			match(LITERAL_implements);
2461 			if ( inputState.guessing==0 ) {
2462 				i_AST.setType(IMPLEMENTS_CLAUSE);
2463 			}
2464 			classOrInterfaceType(false);
2465 			astFactory.addASTChild(currentAST, returnAST);
2466 			{
2467 			_loop143:
2468 			do {
2469 				if ((LA(1)==COMMA)) {
2470 					AST tmp56_AST = null;
2471 					tmp56_AST = astFactory.create(LT(1));
2472 					astFactory.addASTChild(currentAST, tmp56_AST);
2473 					match(COMMA);
2474 					classOrInterfaceType(false);
2475 					astFactory.addASTChild(currentAST, returnAST);
2476 				}
2477 				else {
2478 					break _loop143;
2479 				}
2480 				
2481 			} while (true);
2482 			}
2483 			break;
2484 		}
2485 		case LCURLY:
2486 		{
2487 			break;
2488 		}
2489 		default:
2490 		{
2491 			throw new NoViableAltException(LT(1), getFilename());
2492 		}
2493 		}
2494 		}
2495 		implementsClause_AST = (AST)currentAST.root;
2496 		returnAST = implementsClause_AST;
2497 	}
2498 	
2499 	public final void classBlock() throws RecognitionException, TokenStreamException {
2500 		
2501 		returnAST = null;
2502 		ASTPair currentAST = new ASTPair();
2503 		AST classBlock_AST = null;
2504 		
2505 		AST tmp57_AST = null;
2506 		tmp57_AST = astFactory.create(LT(1));
2507 		astFactory.addASTChild(currentAST, tmp57_AST);
2508 		match(LCURLY);
2509 		{
2510 		_loop135:
2511 		do {
2512 			switch ( LA(1)) {
2513 			case FINAL:
2514 			case ABSTRACT:
2515 			case STRICTFP:
2516 			case LITERAL_void:
2517 			case LITERAL_boolean:
2518 			case LITERAL_byte:
2519 			case LITERAL_char:
2520 			case LITERAL_short:
2521 			case LITERAL_int:
2522 			case LITERAL_float:
2523 			case LITERAL_long:
2524 			case LITERAL_double:
2525 			case IDENT:
2526 			case LITERAL_private:
2527 			case LITERAL_public:
2528 			case LITERAL_protected:
2529 			case LITERAL_static:
2530 			case LITERAL_transient:
2531 			case LITERAL_native:
2532 			case LITERAL_synchronized:
2533 			case LITERAL_volatile:
2534 			case LITERAL_class:
2535 			case LITERAL_interface:
2536 			case LCURLY:
2537 			case LITERAL_default:
2538 			case LT:
2539 			case ENUM:
2540 			case AT:
2541 			{
2542 				field();
2543 				astFactory.addASTChild(currentAST, returnAST);
2544 				break;
2545 			}
2546 			case SEMI:
2547 			{
2548 				AST tmp58_AST = null;
2549 				tmp58_AST = astFactory.create(LT(1));
2550 				astFactory.addASTChild(currentAST, tmp58_AST);
2551 				match(SEMI);
2552 				break;
2553 			}
2554 			default:
2555 			{
2556 				break _loop135;
2557 			}
2558 			}
2559 		} while (true);
2560 		}
2561 		AST tmp59_AST = null;
2562 		tmp59_AST = astFactory.create(LT(1));
2563 		astFactory.addASTChild(currentAST, tmp59_AST);
2564 		match(RCURLY);
2565 		if ( inputState.guessing==0 ) {
2566 			classBlock_AST = (AST)currentAST.root;
2567 			classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(classBlock_AST));
2568 			currentAST.root = classBlock_AST;
2569 			currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ?
2570 				classBlock_AST.getFirstChild() : classBlock_AST;
2571 			currentAST.advanceChildToEnd();
2572 		}
2573 		classBlock_AST = (AST)currentAST.root;
2574 		returnAST = classBlock_AST;
2575 	}
2576 	
2577 	public final void interfaceExtends() throws RecognitionException, TokenStreamException {
2578 		
2579 		returnAST = null;
2580 		ASTPair currentAST = new ASTPair();
2581 		AST interfaceExtends_AST = null;
2582 		Token  e = null;
2583 		AST e_AST = null;
2584 		
2585 		{
2586 		switch ( LA(1)) {
2587 		case LITERAL_extends:
2588 		{
2589 			e = LT(1);
2590 			e_AST = astFactory.create(e);
2591 			astFactory.makeASTRoot(currentAST, e_AST);
2592 			match(LITERAL_extends);
2593 			if ( inputState.guessing==0 ) {
2594 				e_AST.setType(EXTENDS_CLAUSE);
2595 			}
2596 			classOrInterfaceType(false);
2597 			astFactory.addASTChild(currentAST, returnAST);
2598 			{
2599 			_loop139:
2600 			do {
2601 				if ((LA(1)==COMMA)) {
2602 					AST tmp60_AST = null;
2603 					tmp60_AST = astFactory.create(LT(1));
2604 					astFactory.addASTChild(currentAST, tmp60_AST);
2605 					match(COMMA);
2606 					classOrInterfaceType(false);
2607 					astFactory.addASTChild(currentAST, returnAST);
2608 				}
2609 				else {
2610 					break _loop139;
2611 				}
2612 				
2613 			} while (true);
2614 			}
2615 			break;
2616 		}
2617 		case LCURLY:
2618 		{
2619 			break;
2620 		}
2621 		default:
2622 		{
2623 			throw new NoViableAltException(LT(1), getFilename());
2624 		}
2625 		}
2626 		}
2627 		interfaceExtends_AST = (AST)currentAST.root;
2628 		returnAST = interfaceExtends_AST;
2629 	}
2630 	
2631 	public final void enumBlock() throws RecognitionException, TokenStreamException {
2632 		
2633 		returnAST = null;
2634 		ASTPair currentAST = new ASTPair();
2635 		AST enumBlock_AST = null;
2636 		
2637 		AST tmp61_AST = null;
2638 		tmp61_AST = astFactory.create(LT(1));
2639 		astFactory.addASTChild(currentAST, tmp61_AST);
2640 		match(LCURLY);
2641 		{
2642 		switch ( LA(1)) {
2643 		case IDENT:
2644 		case AT:
2645 		{
2646 			enumConstant();
2647 			astFactory.addASTChild(currentAST, returnAST);
2648 			{
2649 			_loop116:
2650 			do {
2651 				if ((LA(1)==COMMA) && (LA(2)==IDENT||LA(2)==AT)) {
2652 					AST tmp62_AST = null;
2653 					tmp62_AST = astFactory.create(LT(1));
2654 					astFactory.addASTChild(currentAST, tmp62_AST);
2655 					match(COMMA);
2656 					enumConstant();
2657 					astFactory.addASTChild(currentAST, returnAST);
2658 				}
2659 				else {
2660 					break _loop116;
2661 				}
2662 				
2663 			} while (true);
2664 			}
2665 			{
2666 			switch ( LA(1)) {
2667 			case COMMA:
2668 			{
2669 				AST tmp63_AST = null;
2670 				tmp63_AST = astFactory.create(LT(1));
2671 				astFactory.addASTChild(currentAST, tmp63_AST);
2672 				match(COMMA);
2673 				break;
2674 			}
2675 			case SEMI:
2676 			case RCURLY:
2677 			{
2678 				break;
2679 			}
2680 			default:
2681 			{
2682 				throw new NoViableAltException(LT(1), getFilename());
2683 			}
2684 			}
2685 			}
2686 			break;
2687 		}
2688 		case SEMI:
2689 		case RCURLY:
2690 		{
2691 			break;
2692 		}
2693 		default:
2694 		{
2695 			throw new NoViableAltException(LT(1), getFilename());
2696 		}
2697 		}
2698 		}
2699 		{
2700 		switch ( LA(1)) {
2701 		case SEMI:
2702 		{
2703 			AST tmp64_AST = null;
2704 			tmp64_AST = astFactory.create(LT(1));
2705 			astFactory.addASTChild(currentAST, tmp64_AST);
2706 			match(SEMI);
2707 			{
2708 			_loop120:
2709 			do {
2710 				switch ( LA(1)) {
2711 				case FINAL:
2712 				case ABSTRACT:
2713 				case STRICTFP:
2714 				case LITERAL_void:
2715 				case LITERAL_boolean:
2716 				case LITERAL_byte:
2717 				case LITERAL_char:
2718 				case LITERAL_short:
2719 				case LITERAL_int:
2720 				case LITERAL_float:
2721 				case LITERAL_long:
2722 				case LITERAL_double:
2723 				case IDENT:
2724 				case LITERAL_private:
2725 				case LITERAL_public:
2726 				case LITERAL_protected:
2727 				case LITERAL_static:
2728 				case LITERAL_transient:
2729 				case LITERAL_native:
2730 				case LITERAL_synchronized:
2731 				case LITERAL_volatile:
2732 				case LITERAL_class:
2733 				case LITERAL_interface:
2734 				case LCURLY:
2735 				case LITERAL_default:
2736 				case LT:
2737 				case ENUM:
2738 				case AT:
2739 				{
2740 					field();
2741 					astFactory.addASTChild(currentAST, returnAST);
2742 					break;
2743 				}
2744 				case SEMI:
2745 				{
2746 					AST tmp65_AST = null;
2747 					tmp65_AST = astFactory.create(LT(1));
2748 					astFactory.addASTChild(currentAST, tmp65_AST);
2749 					match(SEMI);
2750 					break;
2751 				}
2752 				default:
2753 				{
2754 					break _loop120;
2755 				}
2756 				}
2757 			} while (true);
2758 			}
2759 			break;
2760 		}
2761 		case RCURLY:
2762 		{
2763 			break;
2764 		}
2765 		default:
2766 		{
2767 			throw new NoViableAltException(LT(1), getFilename());
2768 		}
2769 		}
2770 		}
2771 		AST tmp66_AST = null;
2772 		tmp66_AST = astFactory.create(LT(1));
2773 		astFactory.addASTChild(currentAST, tmp66_AST);
2774 		match(RCURLY);
2775 		if ( inputState.guessing==0 ) {
2776 			enumBlock_AST = (AST)currentAST.root;
2777 			enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumBlock_AST));
2778 			currentAST.root = enumBlock_AST;
2779 			currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ?
2780 				enumBlock_AST.getFirstChild() : enumBlock_AST;
2781 			currentAST.advanceChildToEnd();
2782 		}
2783 		enumBlock_AST = (AST)currentAST.root;
2784 		returnAST = enumBlock_AST;
2785 	}
2786 	
2787 	public final void annotationBlock() throws RecognitionException, TokenStreamException {
2788 		
2789 		returnAST = null;
2790 		ASTPair currentAST = new ASTPair();
2791 		AST annotationBlock_AST = null;
2792 		
2793 		AST tmp67_AST = null;
2794 		tmp67_AST = astFactory.create(LT(1));
2795 		astFactory.addASTChild(currentAST, tmp67_AST);
2796 		match(LCURLY);
2797 		{
2798 		_loop107:
2799 		do {
2800 			switch ( LA(1)) {
2801 			case FINAL:
2802 			case ABSTRACT:
2803 			case STRICTFP:
2804 			case LITERAL_void:
2805 			case LITERAL_boolean:
2806 			case LITERAL_byte:
2807 			case LITERAL_char:
2808 			case LITERAL_short:
2809 			case LITERAL_int:
2810 			case LITERAL_float:
2811 			case LITERAL_long:
2812 			case LITERAL_double:
2813 			case IDENT:
2814 			case LITERAL_private:
2815 			case LITERAL_public:
2816 			case LITERAL_protected:
2817 			case LITERAL_static:
2818 			case LITERAL_transient:
2819 			case LITERAL_native:
2820 			case LITERAL_synchronized:
2821 			case LITERAL_volatile:
2822 			case LITERAL_class:
2823 			case LITERAL_interface:
2824 			case LITERAL_default:
2825 			case ENUM:
2826 			case AT:
2827 			{
2828 				annotationField();
2829 				astFactory.addASTChild(currentAST, returnAST);
2830 				break;
2831 			}
2832 			case SEMI:
2833 			{
2834 				AST tmp68_AST = null;
2835 				tmp68_AST = astFactory.create(LT(1));
2836 				astFactory.addASTChild(currentAST, tmp68_AST);
2837 				match(SEMI);
2838 				break;
2839 			}
2840 			default:
2841 			{
2842 				break _loop107;
2843 			}
2844 			}
2845 		} while (true);
2846 		}
2847 		AST tmp69_AST = null;
2848 		tmp69_AST = astFactory.create(LT(1));
2849 		astFactory.addASTChild(currentAST, tmp69_AST);
2850 		match(RCURLY);
2851 		if ( inputState.guessing==0 ) {
2852 			annotationBlock_AST = (AST)currentAST.root;
2853 			annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(annotationBlock_AST));
2854 			currentAST.root = annotationBlock_AST;
2855 			currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ?
2856 				annotationBlock_AST.getFirstChild() : annotationBlock_AST;
2857 			currentAST.advanceChildToEnd();
2858 		}
2859 		annotationBlock_AST = (AST)currentAST.root;
2860 		returnAST = annotationBlock_AST;
2861 	}
2862 	
2863 	public final void typeParameter() throws RecognitionException, TokenStreamException {
2864 		
2865 		returnAST = null;
2866 		ASTPair currentAST = new ASTPair();
2867 		AST typeParameter_AST = null;
2868 		Token  id = null;
2869 		AST id_AST = null;
2870 		
2871 		{
2872 		if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_18.member(LA(2))))&&(LA(1) == AT)) {
2873 			annotations();
2874 			astFactory.addASTChild(currentAST, returnAST);
2875 		}
2876 		else if ((LA(1)==IDENT) && (_tokenSet_18.member(LA(2)))) {
2877 		}
2878 		else {
2879 			throw new NoViableAltException(LT(1), getFilename());
2880 		}
2881 		
2882 		}
2883 		{
2884 		id = LT(1);
2885 		id_AST = astFactory.create(id);
2886 		astFactory.addASTChild(currentAST, id_AST);
2887 		match(IDENT);
2888 		}
2889 		{
2890 		if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT||LA(2)==AT)) {
2891 			typeParameterBounds();
2892 			astFactory.addASTChild(currentAST, returnAST);
2893 		}
2894 		else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_19.member(LA(2)))) {
2895 		}
2896 		else {
2897 			throw new NoViableAltException(LT(1), getFilename());
2898 		}
2899 		
2900 		}
2901 		if ( inputState.guessing==0 ) {
2902 			typeParameter_AST = (AST)currentAST.root;
2903 			typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETER,"TYPE_PARAMETER")).add(typeParameter_AST));
2904 			currentAST.root = typeParameter_AST;
2905 			currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ?
2906 				typeParameter_AST.getFirstChild() : typeParameter_AST;
2907 			currentAST.advanceChildToEnd();
2908 		}
2909 		typeParameter_AST = (AST)currentAST.root;
2910 		returnAST = typeParameter_AST;
2911 	}
2912 	
2913 	public final void typeParameterBounds() throws RecognitionException, TokenStreamException {
2914 		
2915 		returnAST = null;
2916 		ASTPair currentAST = new ASTPair();
2917 		AST typeParameterBounds_AST = null;
2918 		Token  e = null;
2919 		AST e_AST = null;
2920 		Token  b = null;
2921 		AST b_AST = null;
2922 		
2923 		e = LT(1);
2924 		e_AST = astFactory.create(e);
2925 		astFactory.makeASTRoot(currentAST, e_AST);
2926 		match(LITERAL_extends);
2927 		classOrInterfaceType(true);
2928 		astFactory.addASTChild(currentAST, returnAST);
2929 		{
2930 		_loop104:
2931 		do {
2932 			if ((LA(1)==BAND)) {
2933 				b = LT(1);
2934 				b_AST = astFactory.create(b);
2935 				astFactory.addASTChild(currentAST, b_AST);
2936 				match(BAND);
2937 				if ( inputState.guessing==0 ) {
2938 					b_AST.setType(TYPE_EXTENSION_AND);
2939 				}
2940 				classOrInterfaceType(true);
2941 				astFactory.addASTChild(currentAST, returnAST);
2942 			}
2943 			else {
2944 				break _loop104;
2945 			}
2946 			
2947 		} while (true);
2948 		}
2949 		if ( inputState.guessing==0 ) {
2950 			e_AST.setType(TYPE_UPPER_BOUNDS);
2951 		}
2952 		typeParameterBounds_AST = (AST)currentAST.root;
2953 		returnAST = typeParameterBounds_AST;
2954 	}
2955 	
2956 	public final void annotationField() throws RecognitionException, TokenStreamException {
2957 		
2958 		returnAST = null;
2959 		ASTPair currentAST = new ASTPair();
2960 		AST annotationField_AST = null;
2961 		AST mods_AST = null;
2962 		AST td_AST = null;
2963 		AST t_AST = null;
2964 		Token  i = null;
2965 		AST i_AST = null;
2966 		AST rt_AST = null;
2967 		AST d_AST = null;
2968 		Token  s = null;
2969 		AST s_AST = null;
2970 		AST v_AST = null;
2971 		Token  s6 = null;
2972 		AST s6_AST = null;
2973 		
2974 		modifiers();
2975 		mods_AST = (AST)returnAST;
2976 		{
2977 		if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
2978 			typeDefinitionInternal(mods_AST);
2979 			td_AST = (AST)returnAST;
2980 			if ( inputState.guessing==0 ) {
2981 				annotationField_AST = (AST)currentAST.root;
2982 				annotationField_AST = td_AST;
2983 				currentAST.root = annotationField_AST;
2984 				currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
2985 					annotationField_AST.getFirstChild() : annotationField_AST;
2986 				currentAST.advanceChildToEnd();
2987 			}
2988 		}
2989 		else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
2990 			typeSpec(false);
2991 			t_AST = (AST)returnAST;
2992 			{
2993 			if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
2994 				i = LT(1);
2995 				i_AST = astFactory.create(i);
2996 				match(IDENT);
2997 				AST tmp70_AST = null;
2998 				tmp70_AST = astFactory.create(LT(1));
2999 				match(LPAREN);
3000 				AST tmp71_AST = null;
3001 				tmp71_AST = astFactory.create(LT(1));
3002 				match(RPAREN);
3003 				declaratorBrackets(t_AST);
3004 				rt_AST = (AST)returnAST;
3005 				{
3006 				switch ( LA(1)) {
3007 				case LITERAL_default:
3008 				{
3009 					annotationDefault();
3010 					d_AST = (AST)returnAST;
3011 					break;
3012 				}
3013 				case SEMI:
3014 				{
3015 					break;
3016 				}
3017 				default:
3018 				{
3019 					throw new NoViableAltException(LT(1), getFilename());
3020 				}
3021 				}
3022 				}
3023 				s = LT(1);
3024 				s_AST = astFactory.create(s);
3025 				match(SEMI);
3026 				if ( inputState.guessing==0 ) {
3027 					annotationField_AST = (AST)currentAST.root;
3028 					annotationField_AST =
3029 					(AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF")).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(i_AST).add(tmp70_AST).add(tmp71_AST).add(d_AST).add(s_AST));
3030 					currentAST.root = annotationField_AST;
3031 					currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
3032 						annotationField_AST.getFirstChild() : annotationField_AST;
3033 					currentAST.advanceChildToEnd();
3034 				}
3035 			}
3036 			else if ((LA(1)==IDENT) && (_tokenSet_22.member(LA(2)))) {
3037 				variableDefinitions(mods_AST,t_AST);
3038 				v_AST = (AST)returnAST;
3039 				s6 = LT(1);
3040 				s6_AST = astFactory.create(s6);
3041 				match(SEMI);
3042 				if ( inputState.guessing==0 ) {
3043 					annotationField_AST = (AST)currentAST.root;
3044 					
3045 					annotationField_AST = v_AST;
3046 					v_AST.addChild(s6_AST);
3047 					
3048 					currentAST.root = annotationField_AST;
3049 					currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ?
3050 						annotationField_AST.getFirstChild() : annotationField_AST;
3051 					currentAST.advanceChildToEnd();
3052 				}
3053 			}
3054 			else {
3055 				throw new NoViableAltException(LT(1), getFilename());
3056 			}
3057 			
3058 			}
3059 		}
3060 		else {
3061 			throw new NoViableAltException(LT(1), getFilename());
3062 		}
3063 		
3064 		}
3065 		returnAST = annotationField_AST;
3066 	}
3067 	
3068 	public final void declaratorBrackets(
3069 		AST typ
3070 	) throws RecognitionException, TokenStreamException {
3071 		
3072 		returnAST = null;
3073 		ASTPair currentAST = new ASTPair();
3074 		AST declaratorBrackets_AST = null;
3075 		Token  lb = null;
3076 		AST lb_AST = null;
3077 		
3078 		if ( inputState.guessing==0 ) {
3079 			declaratorBrackets_AST = (AST)currentAST.root;
3080 			declaratorBrackets_AST=typ;
3081 			currentAST.root = declaratorBrackets_AST;
3082 			currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ?
3083 				declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
3084 			currentAST.advanceChildToEnd();
3085 		}
3086 		{
3087 		_loop169:
3088 		do {
3089 			if ((LA(1)==LBRACK)) {
3090 				lb = LT(1);
3091 				lb_AST = astFactory.create(lb);
3092 				astFactory.makeASTRoot(currentAST, lb_AST);
3093 				match(LBRACK);
3094 				if ( inputState.guessing==0 ) {
3095 					lb_AST.setType(ARRAY_DECLARATOR);
3096 				}
3097 				AST tmp72_AST = null;
3098 				tmp72_AST = astFactory.create(LT(1));
3099 				astFactory.addASTChild(currentAST, tmp72_AST);
3100 				match(RBRACK);
3101 			}
3102 			else {
3103 				break _loop169;
3104 			}
3105 			
3106 		} while (true);
3107 		}
3108 		declaratorBrackets_AST = (AST)currentAST.root;
3109 		returnAST = declaratorBrackets_AST;
3110 	}
3111 	
3112 	public final void annotationDefault() throws RecognitionException, TokenStreamException {
3113 		
3114 		returnAST = null;
3115 		ASTPair currentAST = new ASTPair();
3116 		AST annotationDefault_AST = null;
3117 		
3118 		AST tmp73_AST = null;
3119 		tmp73_AST = astFactory.create(LT(1));
3120 		astFactory.makeASTRoot(currentAST, tmp73_AST);
3121 		match(LITERAL_default);
3122 		annotationMemberValueInitializer();
3123 		astFactory.addASTChild(currentAST, returnAST);
3124 		annotationDefault_AST = (AST)currentAST.root;
3125 		returnAST = annotationDefault_AST;
3126 	}
3127 	
3128 	public final void enumConstant() throws RecognitionException, TokenStreamException {
3129 		
3130 		returnAST = null;
3131 		ASTPair currentAST = new ASTPair();
3132 		AST enumConstant_AST = null;
3133 		AST an_AST = null;
3134 		Token  i = null;
3135 		AST i_AST = null;
3136 		Token  l = null;
3137 		AST l_AST = null;
3138 		AST args_AST = null;
3139 		Token  r = null;
3140 		AST r_AST = null;
3141 		AST b_AST = null;
3142 		
3143 		annotations();
3144 		an_AST = (AST)returnAST;
3145 		i = LT(1);
3146 		i_AST = astFactory.create(i);
3147 		match(IDENT);
3148 		{
3149 		switch ( LA(1)) {
3150 		case LPAREN:
3151 		{
3152 			l = LT(1);
3153 			l_AST = astFactory.create(l);
3154 			match(LPAREN);
3155 			argList();
3156 			args_AST = (AST)returnAST;
3157 			r = LT(1);
3158 			r_AST = astFactory.create(r);
3159 			match(RPAREN);
3160 			break;
3161 		}
3162 		case SEMI:
3163 		case LCURLY:
3164 		case RCURLY:
3165 		case COMMA:
3166 		{
3167 			break;
3168 		}
3169 		default:
3170 		{
3171 			throw new NoViableAltException(LT(1), getFilename());
3172 		}
3173 		}
3174 		}
3175 		{
3176 		switch ( LA(1)) {
3177 		case LCURLY:
3178 		{
3179 			enumConstantBlock();
3180 			b_AST = (AST)returnAST;
3181 			break;
3182 		}
3183 		case SEMI:
3184 		case RCURLY:
3185 		case COMMA:
3186 		{
3187 			break;
3188 		}
3189 		default:
3190 		{
3191 			throw new NoViableAltException(LT(1), getFilename());
3192 		}
3193 		}
3194 		}
3195 		if ( inputState.guessing==0 ) {
3196 			enumConstant_AST = (AST)currentAST.root;
3197 			enumConstant_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF")).add(an_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST).add(b_AST));
3198 			currentAST.root = enumConstant_AST;
3199 			currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ?
3200 				enumConstant_AST.getFirstChild() : enumConstant_AST;
3201 			currentAST.advanceChildToEnd();
3202 		}
3203 		returnAST = enumConstant_AST;
3204 	}
3205 	
3206 	public final void field() throws RecognitionException, TokenStreamException {
3207 		
3208 		returnAST = null;
3209 		ASTPair currentAST = new ASTPair();
3210 		AST field_AST = null;
3211 		AST mods_AST = null;
3212 		AST td_AST = null;
3213 		AST tp_AST = null;
3214 		AST h_AST = null;
3215 		AST s_AST = null;
3216 		AST t_AST = null;
3217 		AST param_AST = null;
3218 		AST rt_AST = null;
3219 		AST tc_AST = null;
3220 		AST s2_AST = null;
3221 		Token  s5 = null;
3222 		AST s5_AST = null;
3223 		AST v_AST = null;
3224 		Token  s6 = null;
3225 		AST s6_AST = null;
3226 		Token  si = null;
3227 		AST si_AST = null;
3228 		AST s3_AST = null;
3229 		AST s4_AST = null;
3230 		
3231 		if ((_tokenSet_23.member(LA(1))) && (_tokenSet_24.member(LA(2)))) {
3232 			modifiers();
3233 			mods_AST = (AST)returnAST;
3234 			{
3235 			if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
3236 				typeDefinitionInternal(mods_AST);
3237 				td_AST = (AST)returnAST;
3238 				if ( inputState.guessing==0 ) {
3239 					field_AST = (AST)currentAST.root;
3240 					field_AST = td_AST;
3241 					currentAST.root = field_AST;
3242 					currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3243 						field_AST.getFirstChild() : field_AST;
3244 					currentAST.advanceChildToEnd();
3245 				}
3246 			}
3247 			else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
3248 				{
3249 				switch ( LA(1)) {
3250 				case LT:
3251 				{
3252 					typeParameters();
3253 					tp_AST = (AST)returnAST;
3254 					break;
3255 				}
3256 				case LITERAL_void:
3257 				case LITERAL_boolean:
3258 				case LITERAL_byte:
3259 				case LITERAL_char:
3260 				case LITERAL_short:
3261 				case LITERAL_int:
3262 				case LITERAL_float:
3263 				case LITERAL_long:
3264 				case LITERAL_double:
3265 				case IDENT:
3266 				case AT:
3267 				{
3268 					break;
3269 				}
3270 				default:
3271 				{
3272 					throw new NoViableAltException(LT(1), getFilename());
3273 				}
3274 				}
3275 				}
3276 				{
3277 				if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
3278 					ctorHead();
3279 					h_AST = (AST)returnAST;
3280 					constructorBody();
3281 					s_AST = (AST)returnAST;
3282 					if ( inputState.guessing==0 ) {
3283 						field_AST = (AST)currentAST.root;
3284 						field_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(CTOR_DEF,"CTOR_DEF")).add(mods_AST).add(tp_AST).add(h_AST).add(s_AST));
3285 						currentAST.root = field_AST;
3286 						currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3287 							field_AST.getFirstChild() : field_AST;
3288 						currentAST.advanceChildToEnd();
3289 					}
3290 				}
3291 				else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
3292 					typeSpec(false);
3293 					t_AST = (AST)returnAST;
3294 					{
3295 					if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
3296 						AST tmp74_AST = null;
3297 						tmp74_AST = astFactory.create(LT(1));
3298 						match(IDENT);
3299 						AST tmp75_AST = null;
3300 						tmp75_AST = astFactory.create(LT(1));
3301 						match(LPAREN);
3302 						parameterDeclarationList();
3303 						param_AST = (AST)returnAST;
3304 						AST tmp76_AST = null;
3305 						tmp76_AST = astFactory.create(LT(1));
3306 						match(RPAREN);
3307 						declaratorBrackets(t_AST);
3308 						rt_AST = (AST)returnAST;
3309 						{
3310 						switch ( LA(1)) {
3311 						case LITERAL_throws:
3312 						{
3313 							throwsClause();
3314 							tc_AST = (AST)returnAST;
3315 							break;
3316 						}
3317 						case SEMI:
3318 						case LCURLY:
3319 						{
3320 							break;
3321 						}
3322 						default:
3323 						{
3324 							throw new NoViableAltException(LT(1), getFilename());
3325 						}
3326 						}
3327 						}
3328 						{
3329 						switch ( LA(1)) {
3330 						case LCURLY:
3331 						{
3332 							compoundStatement();
3333 							s2_AST = (AST)returnAST;
3334 							break;
3335 						}
3336 						case SEMI:
3337 						{
3338 							s5 = LT(1);
3339 							s5_AST = astFactory.create(s5);
3340 							match(SEMI);
3341 							break;
3342 						}
3343 						default:
3344 						{
3345 							throw new NoViableAltException(LT(1), getFilename());
3346 						}
3347 						}
3348 						}
3349 						if ( inputState.guessing==0 ) {
3350 							field_AST = (AST)currentAST.root;
3351 							field_AST = (AST)astFactory.make( (new ASTArray(11)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp74_AST).add(tmp75_AST).add(param_AST).add(tmp76_AST).add(tc_AST).add(s2_AST).add(s5_AST));
3352 							currentAST.root = field_AST;
3353 							currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3354 								field_AST.getFirstChild() : field_AST;
3355 							currentAST.advanceChildToEnd();
3356 						}
3357 					}
3358 					else if ((LA(1)==IDENT) && (_tokenSet_27.member(LA(2)))) {
3359 						variableDefinitions(mods_AST,t_AST);
3360 						v_AST = (AST)returnAST;
3361 						{
3362 						if ((LA(1)==SEMI) && (_tokenSet_28.member(LA(2)))) {
3363 							s6 = LT(1);
3364 							s6_AST = astFactory.create(s6);
3365 							match(SEMI);
3366 						}
3367 						else if ((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2)))) {
3368 						}
3369 						else {
3370 							throw new NoViableAltException(LT(1), getFilename());
3371 						}
3372 						
3373 						}
3374 						if ( inputState.guessing==0 ) {
3375 							field_AST = (AST)currentAST.root;
3376 							
3377 							field_AST = v_AST;
3378 							v_AST.addChild(s6_AST);
3379 							
3380 							currentAST.root = field_AST;
3381 							currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3382 								field_AST.getFirstChild() : field_AST;
3383 							currentAST.advanceChildToEnd();
3384 						}
3385 					}
3386 					else {
3387 						throw new NoViableAltException(LT(1), getFilename());
3388 					}
3389 					
3390 					}
3391 				}
3392 				else {
3393 					throw new NoViableAltException(LT(1), getFilename());
3394 				}
3395 				
3396 				}
3397 			}
3398 			else {
3399 				throw new NoViableAltException(LT(1), getFilename());
3400 			}
3401 			
3402 			}
3403 		}
3404 		else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) {
3405 			si = LT(1);
3406 			si_AST = astFactory.create(si);
3407 			match(LITERAL_static);
3408 			compoundStatement();
3409 			s3_AST = (AST)returnAST;
3410 			if ( inputState.guessing==0 ) {
3411 				field_AST = (AST)currentAST.root;
3412 				si_AST.setType(STATIC_INIT);
3413 				si_AST.setText("STATIC_INIT");
3414 				field_AST = (AST)astFactory.make( (new ASTArray(2)).add(si_AST).add(s3_AST));
3415 				currentAST.root = field_AST;
3416 				currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3417 					field_AST.getFirstChild() : field_AST;
3418 				currentAST.advanceChildToEnd();
3419 			}
3420 		}
3421 		else if ((LA(1)==LCURLY)) {
3422 			compoundStatement();
3423 			s4_AST = (AST)returnAST;
3424 			if ( inputState.guessing==0 ) {
3425 				field_AST = (AST)currentAST.root;
3426 				field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST));
3427 				currentAST.root = field_AST;
3428 				currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
3429 					field_AST.getFirstChild() : field_AST;
3430 				currentAST.advanceChildToEnd();
3431 			}
3432 		}
3433 		else {
3434 			throw new NoViableAltException(LT(1), getFilename());
3435 		}
3436 		
3437 		returnAST = field_AST;
3438 	}
3439 	
3440 	public final void argList() throws RecognitionException, TokenStreamException {
3441 		
3442 		returnAST = null;
3443 		ASTPair currentAST = new ASTPair();
3444 		AST argList_AST = null;
3445 		
3446 		{
3447 		if (((_tokenSet_12.member(LA(1))))&&(LA(1)!=RPAREN)) {
3448 			expressionList();
3449 			astFactory.addASTChild(currentAST, returnAST);
3450 		}
3451 		else if ((LA(1)==RPAREN)) {
3452 			if ( inputState.guessing==0 ) {
3453 				argList_AST = (AST)currentAST.root;
3454 				argList_AST = astFactory.create(ELIST,"ELIST");
3455 				currentAST.root = argList_AST;
3456 				currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
3457 					argList_AST.getFirstChild() : argList_AST;
3458 				currentAST.advanceChildToEnd();
3459 			}
3460 		}
3461 		else {
3462 			throw new NoViableAltException(LT(1), getFilename());
3463 		}
3464 		
3465 		}
3466 		argList_AST = (AST)currentAST.root;
3467 		returnAST = argList_AST;
3468 	}
3469 	
3470 	public final void enumConstantBlock() throws RecognitionException, TokenStreamException {
3471 		
3472 		returnAST = null;
3473 		ASTPair currentAST = new ASTPair();
3474 		AST enumConstantBlock_AST = null;
3475 		
3476 		AST tmp77_AST = null;
3477 		tmp77_AST = astFactory.create(LT(1));
3478 		astFactory.addASTChild(currentAST, tmp77_AST);
3479 		match(LCURLY);
3480 		{
3481 		_loop126:
3482 		do {
3483 			switch ( LA(1)) {
3484 			case FINAL:
3485 			case ABSTRACT:
3486 			case STRICTFP:
3487 			case LITERAL_void:
3488 			case LITERAL_boolean:
3489 			case LITERAL_byte:
3490 			case LITERAL_char:
3491 			case LITERAL_short:
3492 			case LITERAL_int:
3493 			case LITERAL_float:
3494 			case LITERAL_long:
3495 			case LITERAL_double:
3496 			case IDENT:
3497 			case LITERAL_private:
3498 			case LITERAL_public:
3499 			case LITERAL_protected:
3500 			case LITERAL_static:
3501 			case LITERAL_transient:
3502 			case LITERAL_native:
3503 			case LITERAL_synchronized:
3504 			case LITERAL_volatile:
3505 			case LITERAL_class:
3506 			case LITERAL_interface:
3507 			case LCURLY:
3508 			case LITERAL_default:
3509 			case LT:
3510 			case ENUM:
3511 			case AT:
3512 			{
3513 				enumConstantField();
3514 				astFactory.addASTChild(currentAST, returnAST);
3515 				break;
3516 			}
3517 			case SEMI:
3518 			{
3519 				AST tmp78_AST = null;
3520 				tmp78_AST = astFactory.create(LT(1));
3521 				astFactory.addASTChild(currentAST, tmp78_AST);
3522 				match(SEMI);
3523 				break;
3524 			}
3525 			default:
3526 			{
3527 				break _loop126;
3528 			}
3529 			}
3530 		} while (true);
3531 		}
3532 		AST tmp79_AST = null;
3533 		tmp79_AST = astFactory.create(LT(1));
3534 		astFactory.addASTChild(currentAST, tmp79_AST);
3535 		match(RCURLY);
3536 		if ( inputState.guessing==0 ) {
3537 			enumConstantBlock_AST = (AST)currentAST.root;
3538 			enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumConstantBlock_AST));
3539 			currentAST.root = enumConstantBlock_AST;
3540 			currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ?
3541 				enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST;
3542 			currentAST.advanceChildToEnd();
3543 		}
3544 		enumConstantBlock_AST = (AST)currentAST.root;
3545 		returnAST = enumConstantBlock_AST;
3546 	}
3547 	
3548 	public final void enumConstantField() throws RecognitionException, TokenStreamException {
3549 		
3550 		returnAST = null;
3551 		ASTPair currentAST = new ASTPair();
3552 		AST enumConstantField_AST = null;
3553 		AST mods_AST = null;
3554 		AST td_AST = null;
3555 		AST tp_AST = null;
3556 		AST t_AST = null;
3557 		AST param_AST = null;
3558 		AST rt_AST = null;
3559 		AST tc_AST = null;
3560 		AST s2_AST = null;
3561 		Token  s3 = null;
3562 		AST s3_AST = null;
3563 		AST v_AST = null;
3564 		Token  s6 = null;
3565 		AST s6_AST = null;
3566 		AST s4_AST = null;
3567 		
3568 		switch ( LA(1)) {
3569 		case FINAL:
3570 		case ABSTRACT:
3571 		case STRICTFP:
3572 		case LITERAL_void:
3573 		case LITERAL_boolean:
3574 		case LITERAL_byte:
3575 		case LITERAL_char:
3576 		case LITERAL_short:
3577 		case LITERAL_int:
3578 		case LITERAL_float:
3579 		case LITERAL_long:
3580 		case LITERAL_double:
3581 		case IDENT:
3582 		case LITERAL_private:
3583 		case LITERAL_public:
3584 		case LITERAL_protected:
3585 		case LITERAL_static:
3586 		case LITERAL_transient:
3587 		case LITERAL_native:
3588 		case LITERAL_synchronized:
3589 		case LITERAL_volatile:
3590 		case LITERAL_class:
3591 		case LITERAL_interface:
3592 		case LITERAL_default:
3593 		case LT:
3594 		case ENUM:
3595 		case AT:
3596 		{
3597 			modifiers();
3598 			mods_AST = (AST)returnAST;
3599 			{
3600 			if ((_tokenSet_20.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) {
3601 				typeDefinitionInternal(mods_AST);
3602 				td_AST = (AST)returnAST;
3603 				if ( inputState.guessing==0 ) {
3604 					enumConstantField_AST = (AST)currentAST.root;
3605 					enumConstantField_AST = td_AST;
3606 					currentAST.root = enumConstantField_AST;
3607 					currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
3608 						enumConstantField_AST.getFirstChild() : enumConstantField_AST;
3609 					currentAST.advanceChildToEnd();
3610 				}
3611 			}
3612 			else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_21.member(LA(2)))) {
3613 				{
3614 				switch ( LA(1)) {
3615 				case LT:
3616 				{
3617 					typeParameters();
3618 					tp_AST = (AST)returnAST;
3619 					break;
3620 				}
3621 				case LITERAL_void:
3622 				case LITERAL_boolean:
3623 				case LITERAL_byte:
3624 				case LITERAL_char:
3625 				case LITERAL_short:
3626 				case LITERAL_int:
3627 				case LITERAL_float:
3628 				case LITERAL_long:
3629 				case LITERAL_double:
3630 				case IDENT:
3631 				case AT:
3632 				{
3633 					break;
3634 				}
3635 				default:
3636 				{
3637 					throw new NoViableAltException(LT(1), getFilename());
3638 				}
3639 				}
3640 				}
3641 				typeSpec(false);
3642 				t_AST = (AST)returnAST;
3643 				{
3644 				if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
3645 					AST tmp80_AST = null;
3646 					tmp80_AST = astFactory.create(LT(1));
3647 					match(IDENT);
3648 					AST tmp81_AST = null;
3649 					tmp81_AST = astFactory.create(LT(1));
3650 					match(LPAREN);
3651 					parameterDeclarationList();
3652 					param_AST = (AST)returnAST;
3653 					AST tmp82_AST = null;
3654 					tmp82_AST = astFactory.create(LT(1));
3655 					match(RPAREN);
3656 					declaratorBrackets(t_AST);
3657 					rt_AST = (AST)returnAST;
3658 					{
3659 					switch ( LA(1)) {
3660 					case LITERAL_throws:
3661 					{
3662 						throwsClause();
3663 						tc_AST = (AST)returnAST;
3664 						break;
3665 					}
3666 					case SEMI:
3667 					case LCURLY:
3668 					{
3669 						break;
3670 					}
3671 					default:
3672 					{
3673 						throw new NoViableAltException(LT(1), getFilename());
3674 					}
3675 					}
3676 					}
3677 					{
3678 					switch ( LA(1)) {
3679 					case LCURLY:
3680 					{
3681 						compoundStatement();
3682 						s2_AST = (AST)returnAST;
3683 						break;
3684 					}
3685 					case SEMI:
3686 					{
3687 						s3 = LT(1);
3688 						s3_AST = astFactory.create(s3);
3689 						match(SEMI);
3690 						break;
3691 					}
3692 					default:
3693 					{
3694 						throw new NoViableAltException(LT(1), getFilename());
3695 					}
3696 					}
3697 					}
3698 					if ( inputState.guessing==0 ) {
3699 						enumConstantField_AST = (AST)currentAST.root;
3700 						enumConstantField_AST = (AST)astFactory.make( (new ASTArray(11)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp80_AST).add(tmp81_AST).add(param_AST).add(tmp82_AST).add(tc_AST).add(s2_AST).add(s3_AST));
3701 						currentAST.root = enumConstantField_AST;
3702 						currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
3703 							enumConstantField_AST.getFirstChild() : enumConstantField_AST;
3704 						currentAST.advanceChildToEnd();
3705 					}
3706 				}
3707 				else if ((LA(1)==IDENT) && (_tokenSet_22.member(LA(2)))) {
3708 					variableDefinitions(mods_AST,t_AST);
3709 					v_AST = (AST)returnAST;
3710 					s6 = LT(1);
3711 					s6_AST = astFactory.create(s6);
3712 					match(SEMI);
3713 					if ( inputState.guessing==0 ) {
3714 						enumConstantField_AST = (AST)currentAST.root;
3715 						
3716 						enumConstantField_AST = v_AST;
3717 						v_AST.addChild(s6_AST);
3718 						
3719 						currentAST.root = enumConstantField_AST;
3720 						currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
3721 							enumConstantField_AST.getFirstChild() : enumConstantField_AST;
3722 						currentAST.advanceChildToEnd();
3723 					}
3724 				}
3725 				else {
3726 					throw new NoViableAltException(LT(1), getFilename());
3727 				}
3728 				
3729 				}
3730 			}
3731 			else {
3732 				throw new NoViableAltException(LT(1), getFilename());
3733 			}
3734 			
3735 			}
3736 			break;
3737 		}
3738 		case LCURLY:
3739 		{
3740 			compoundStatement();
3741 			s4_AST = (AST)returnAST;
3742 			if ( inputState.guessing==0 ) {
3743 				enumConstantField_AST = (AST)currentAST.root;
3744 				enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST));
3745 				currentAST.root = enumConstantField_AST;
3746 				currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ?
3747 					enumConstantField_AST.getFirstChild() : enumConstantField_AST;
3748 				currentAST.advanceChildToEnd();
3749 			}
3750 			break;
3751 		}
3752 		default:
3753 		{
3754 			throw new NoViableAltException(LT(1), getFilename());
3755 		}
3756 		}
3757 		returnAST = enumConstantField_AST;
3758 	}
3759 	
3760 	public final void parameterDeclarationList() throws RecognitionException, TokenStreamException {
3761 		
3762 		returnAST = null;
3763 		ASTPair currentAST = new ASTPair();
3764 		AST parameterDeclarationList_AST = null;
3765 		
3766 		{
3767 		boolean synPredMatched188 = false;
3768 		if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31.member(LA(2))))) {
3769 			int _m188 = mark();
3770 			synPredMatched188 = true;
3771 			inputState.guessing++;
3772 			try {
3773 				{
3774 				parameterDeclaration();
3775 				}
3776 			}
3777 			catch (RecognitionException pe) {
3778 				synPredMatched188 = false;
3779 			}
3780 			rewind(_m188);
3781 inputState.guessing--;
3782 		}
3783 		if ( synPredMatched188 ) {
3784 			parameterDeclaration();
3785 			astFactory.addASTChild(currentAST, returnAST);
3786 			{
3787 			_loop192:
3788 			do {
3789 				boolean synPredMatched191 = false;
3790 				if (((LA(1)==COMMA) && (_tokenSet_30.member(LA(2))))) {
3791 					int _m191 = mark();
3792 					synPredMatched191 = true;
3793 					inputState.guessing++;
3794 					try {
3795 						{
3796 						match(COMMA);
3797 						parameterDeclaration();
3798 						}
3799 					}
3800 					catch (RecognitionException pe) {
3801 						synPredMatched191 = false;
3802 					}
3803 					rewind(_m191);
3804 inputState.guessing--;
3805 				}
3806 				if ( synPredMatched191 ) {
3807 					AST tmp83_AST = null;
3808 					tmp83_AST = astFactory.create(LT(1));
3809 					astFactory.addASTChild(currentAST, tmp83_AST);
3810 					match(COMMA);
3811 					parameterDeclaration();
3812 					astFactory.addASTChild(currentAST, returnAST);
3813 				}
3814 				else {
3815 					break _loop192;
3816 				}
3817 				
3818 			} while (true);
3819 			}
3820 			{
3821 			switch ( LA(1)) {
3822 			case COMMA:
3823 			{
3824 				AST tmp84_AST = null;
3825 				tmp84_AST = astFactory.create(LT(1));
3826 				astFactory.addASTChild(currentAST, tmp84_AST);
3827 				match(COMMA);
3828 				variableLengthParameterDeclaration();
3829 				astFactory.addASTChild(currentAST, returnAST);
3830 				break;
3831 			}
3832 			case RPAREN:
3833 			{
3834 				break;
3835 			}
3836 			default:
3837 			{
3838 				throw new NoViableAltException(LT(1), getFilename());
3839 			}
3840 			}
3841 			}
3842 		}
3843 		else if ((_tokenSet_32.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
3844 			variableLengthParameterDeclaration();
3845 			astFactory.addASTChild(currentAST, returnAST);
3846 		}
3847 		else if ((LA(1)==RPAREN)) {
3848 		}
3849 		else {
3850 			throw new NoViableAltException(LT(1), getFilename());
3851 		}
3852 		
3853 		}
3854 		if ( inputState.guessing==0 ) {
3855 			parameterDeclarationList_AST = (AST)currentAST.root;
3856 			parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PARAMETERS,"PARAMETERS")).add(parameterDeclarationList_AST));
3857 			currentAST.root = parameterDeclarationList_AST;
3858 			currentAST.child = parameterDeclarationList_AST!=null &&parameterDeclarationList_AST.getFirstChild()!=null ?
3859 				parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST;
3860 			currentAST.advanceChildToEnd();
3861 		}
3862 		parameterDeclarationList_AST = (AST)currentAST.root;
3863 		returnAST = parameterDeclarationList_AST;
3864 	}
3865 	
3866 	public final void throwsClause() throws RecognitionException, TokenStreamException {
3867 		
3868 		returnAST = null;
3869 		ASTPair currentAST = new ASTPair();
3870 		AST throwsClause_AST = null;
3871 		
3872 		AST tmp85_AST = null;
3873 		tmp85_AST = astFactory.create(LT(1));
3874 		astFactory.makeASTRoot(currentAST, tmp85_AST);
3875 		match(LITERAL_throws);
3876 		{
3877 		if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_34.member(LA(2))))&&(LA(1) == AT)) {
3878 			annotations();
3879 			astFactory.addASTChild(currentAST, returnAST);
3880 		}
3881 		else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) {
3882 		}
3883 		else {
3884 			throw new NoViableAltException(LT(1), getFilename());
3885 		}
3886 		
3887 		}
3888 		identifier();
3889 		astFactory.addASTChild(currentAST, returnAST);
3890 		{
3891 		_loop184:
3892 		do {
3893 			if ((LA(1)==COMMA)) {
3894 				AST tmp86_AST = null;
3895 				tmp86_AST = astFactory.create(LT(1));
3896 				astFactory.addASTChild(currentAST, tmp86_AST);
3897 				match(COMMA);
3898 				{
3899 				if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_34.member(LA(2))))&&(LA(1) == AT)) {
3900 					annotations();
3901 					astFactory.addASTChild(currentAST, returnAST);
3902 				}
3903 				else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) {
3904 				}
3905 				else {
3906 					throw new NoViableAltException(LT(1), getFilename());
3907 				}
3908 				
3909 				}
3910 				identifier();
3911 				astFactory.addASTChild(currentAST, returnAST);
3912 			}
3913 			else {
3914 				break _loop184;
3915 			}
3916 			
3917 		} while (true);
3918 		}
3919 		throwsClause_AST = (AST)currentAST.root;
3920 		returnAST = throwsClause_AST;
3921 	}
3922 	
3923 	public final void compoundStatement() throws RecognitionException, TokenStreamException {
3924 		
3925 		returnAST = null;
3926 		ASTPair currentAST = new ASTPair();
3927 		AST compoundStatement_AST = null;
3928 		Token  lc = null;
3929 		AST lc_AST = null;
3930 		
3931 		lc = LT(1);
3932 		lc_AST = astFactory.create(lc);
3933 		astFactory.makeASTRoot(currentAST, lc_AST);
3934 		match(LCURLY);
3935 		if ( inputState.guessing==0 ) {
3936 			lc_AST.setType(SLIST);
3937 		}
3938 		{
3939 		_loop212:
3940 		do {
3941 			if ((_tokenSet_36.member(LA(1)))) {
3942 				statement();
3943 				astFactory.addASTChild(currentAST, returnAST);
3944 			}
3945 			else {
3946 				break _loop212;
3947 			}
3948 			
3949 		} while (true);
3950 		}
3951 		AST tmp87_AST = null;
3952 		tmp87_AST = astFactory.create(LT(1));
3953 		astFactory.addASTChild(currentAST, tmp87_AST);
3954 		match(RCURLY);
3955 		compoundStatement_AST = (AST)currentAST.root;
3956 		returnAST = compoundStatement_AST;
3957 	}
3958 	
3959 	public final void ctorHead() throws RecognitionException, TokenStreamException {
3960 		
3961 		returnAST = null;
3962 		ASTPair currentAST = new ASTPair();
3963 		AST ctorHead_AST = null;
3964 		
3965 		AST tmp88_AST = null;
3966 		tmp88_AST = astFactory.create(LT(1));
3967 		astFactory.addASTChild(currentAST, tmp88_AST);
3968 		match(IDENT);
3969 		AST tmp89_AST = null;
3970 		tmp89_AST = astFactory.create(LT(1));
3971 		astFactory.addASTChild(currentAST, tmp89_AST);
3972 		match(LPAREN);
3973 		parameterDeclarationList();
3974 		astFactory.addASTChild(currentAST, returnAST);
3975 		AST tmp90_AST = null;
3976 		tmp90_AST = astFactory.create(LT(1));
3977 		astFactory.addASTChild(currentAST, tmp90_AST);
3978 		match(RPAREN);
3979 		{
3980 		switch ( LA(1)) {
3981 		case LITERAL_throws:
3982 		{
3983 			throwsClause();
3984 			astFactory.addASTChild(currentAST, returnAST);
3985 			break;
3986 		}
3987 		case LCURLY:
3988 		{
3989 			break;
3990 		}
3991 		default:
3992 		{
3993 			throw new NoViableAltException(LT(1), getFilename());
3994 		}
3995 		}
3996 		}
3997 		ctorHead_AST = (AST)currentAST.root;
3998 		returnAST = ctorHead_AST;
3999 	}
4000 	
4001 	public final void constructorBody() throws RecognitionException, TokenStreamException {
4002 		
4003 		returnAST = null;
4004 		ASTPair currentAST = new ASTPair();
4005 		AST constructorBody_AST = null;
4006 		Token  lc = null;
4007 		AST lc_AST = null;
4008 		
4009 		lc = LT(1);
4010 		lc_AST = astFactory.create(lc);
4011 		astFactory.makeASTRoot(currentAST, lc_AST);
4012 		match(LCURLY);
4013 		if ( inputState.guessing==0 ) {
4014 			lc_AST.setType(SLIST);
4015 		}
4016 		{
4017 		boolean synPredMatched155 = false;
4018 		if (((_tokenSet_37.member(LA(1))) && (_tokenSet_38.member(LA(2))))) {
4019 			int _m155 = mark();
4020 			synPredMatched155 = true;
4021 			inputState.guessing++;
4022 			try {
4023 				{
4024 				explicitConstructorInvocation();
4025 				}
4026 			}
4027 			catch (RecognitionException pe) {
4028 				synPredMatched155 = false;
4029 			}
4030 			rewind(_m155);
4031 inputState.guessing--;
4032 		}
4033 		if ( synPredMatched155 ) {
4034 			explicitConstructorInvocation();
4035 			astFactory.addASTChild(currentAST, returnAST);
4036 		}
4037 		else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_40.member(LA(2)))) {
4038 		}
4039 		else {
4040 			throw new NoViableAltException(LT(1), getFilename());
4041 		}
4042 		
4043 		}
4044 		{
4045 		_loop157:
4046 		do {
4047 			if ((_tokenSet_36.member(LA(1)))) {
4048 				statement();
4049 				astFactory.addASTChild(currentAST, returnAST);
4050 			}
4051 			else {
4052 				break _loop157;
4053 			}
4054 			
4055 		} while (true);
4056 		}
4057 		AST tmp91_AST = null;
4058 		tmp91_AST = astFactory.create(LT(1));
4059 		astFactory.addASTChild(currentAST, tmp91_AST);
4060 		match(RCURLY);
4061 		constructorBody_AST = (AST)currentAST.root;
4062 		returnAST = constructorBody_AST;
4063 	}
4064 	
4065 	public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException {
4066 		
4067 		returnAST = null;
4068 		ASTPair currentAST = new ASTPair();
4069 		AST explicitConstructorInvocation_AST = null;
4070 		Token  t = null;
4071 		AST t_AST = null;
4072 		Token  s = null;
4073 		AST s_AST = null;
4074 		Token  s1 = null;
4075 		AST s1_AST = null;
4076 		
4077 		{
4078 		if ((_tokenSet_41.member(LA(1))) && (_tokenSet_42.member(LA(2)))) {
4079 			{
4080 			switch ( LA(1)) {
4081 			case LT:
4082 			{
4083 				typeArguments(false);
4084 				astFactory.addASTChild(currentAST, returnAST);
4085 				break;
4086 			}
4087 			case LITERAL_this:
4088 			case LITERAL_super:
4089 			{
4090 				break;
4091 			}
4092 			default:
4093 			{
4094 				throw new NoViableAltException(LT(1), getFilename());
4095 			}
4096 			}
4097 			}
4098 			{
4099 			switch ( LA(1)) {
4100 			case LITERAL_this:
4101 			{
4102 				t = LT(1);
4103 				t_AST = astFactory.create(t);
4104 				astFactory.makeASTRoot(currentAST, t_AST);
4105 				match(LITERAL_this);
4106 				AST tmp92_AST = null;
4107 				tmp92_AST = astFactory.create(LT(1));
4108 				astFactory.addASTChild(currentAST, tmp92_AST);
4109 				match(LPAREN);
4110 				argList();
4111 				astFactory.addASTChild(currentAST, returnAST);
4112 				AST tmp93_AST = null;
4113 				tmp93_AST = astFactory.create(LT(1));
4114 				astFactory.addASTChild(currentAST, tmp93_AST);
4115 				match(RPAREN);
4116 				AST tmp94_AST = null;
4117 				tmp94_AST = astFactory.create(LT(1));
4118 				astFactory.addASTChild(currentAST, tmp94_AST);
4119 				match(SEMI);
4120 				if ( inputState.guessing==0 ) {
4121 					t_AST.setType(CTOR_CALL);
4122 				}
4123 				break;
4124 			}
4125 			case LITERAL_super:
4126 			{
4127 				s = LT(1);
4128 				s_AST = astFactory.create(s);
4129 				astFactory.makeASTRoot(currentAST, s_AST);
4130 				match(LITERAL_super);
4131 				AST tmp95_AST = null;
4132 				tmp95_AST = astFactory.create(LT(1));
4133 				astFactory.addASTChild(currentAST, tmp95_AST);
4134 				match(LPAREN);
4135 				argList();
4136 				astFactory.addASTChild(currentAST, returnAST);
4137 				AST tmp96_AST = null;
4138 				tmp96_AST = astFactory.create(LT(1));
4139 				astFactory.addASTChild(currentAST, tmp96_AST);
4140 				match(RPAREN);
4141 				AST tmp97_AST = null;
4142 				tmp97_AST = astFactory.create(LT(1));
4143 				astFactory.addASTChild(currentAST, tmp97_AST);
4144 				match(SEMI);
4145 				if ( inputState.guessing==0 ) {
4146 					s_AST.setType(SUPER_CTOR_CALL);
4147 				}
4148 				break;
4149 			}
4150 			default:
4151 			{
4152 				throw new NoViableAltException(LT(1), getFilename());
4153 			}
4154 			}
4155 			}
4156 		}
4157 		else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_44.member(LA(2)))) {
4158 			primaryExpression();
4159 			astFactory.addASTChild(currentAST, returnAST);
4160 			AST tmp98_AST = null;
4161 			tmp98_AST = astFactory.create(LT(1));
4162 			astFactory.addASTChild(currentAST, tmp98_AST);
4163 			match(DOT);
4164 			{
4165 			switch ( LA(1)) {
4166 			case LT:
4167 			{
4168 				typeArguments(false);
4169 				astFactory.addASTChild(currentAST, returnAST);
4170 				break;
4171 			}
4172 			case LITERAL_super:
4173 			{
4174 				break;
4175 			}
4176 			default:
4177 			{
4178 				throw new NoViableAltException(LT(1), getFilename());
4179 			}
4180 			}
4181 			}
4182 			s1 = LT(1);
4183 			s1_AST = astFactory.create(s1);
4184 			astFactory.makeASTRoot(currentAST, s1_AST);
4185 			match(LITERAL_super);
4186 			AST tmp99_AST = null;
4187 			tmp99_AST = astFactory.create(LT(1));
4188 			astFactory.addASTChild(currentAST, tmp99_AST);
4189 			match(LPAREN);
4190 			argList();
4191 			astFactory.addASTChild(currentAST, returnAST);
4192 			AST tmp100_AST = null;
4193 			tmp100_AST = astFactory.create(LT(1));
4194 			astFactory.addASTChild(currentAST, tmp100_AST);
4195 			match(RPAREN);
4196 			AST tmp101_AST = null;
4197 			tmp101_AST = astFactory.create(LT(1));
4198 			astFactory.addASTChild(currentAST, tmp101_AST);
4199 			match(SEMI);
4200 			if ( inputState.guessing==0 ) {
4201 				s1_AST.setType(SUPER_CTOR_CALL);
4202 			}
4203 		}
4204 		else {
4205 			throw new NoViableAltException(LT(1), getFilename());
4206 		}
4207 		
4208 		}
4209 		explicitConstructorInvocation_AST = (AST)currentAST.root;
4210 		returnAST = explicitConstructorInvocation_AST;
4211 	}
4212 	
4213 	public final void statement() throws RecognitionException, TokenStreamException {
4214 		
4215 		returnAST = null;
4216 		ASTPair currentAST = new ASTPair();
4217 		AST statement_AST = null;
4218 		
4219 		switch ( LA(1)) {
4220 		case FINAL:
4221 		case ABSTRACT:
4222 		case STRICTFP:
4223 		case SEMI:
4224 		case LITERAL_void:
4225 		case LITERAL_boolean:
4226 		case LITERAL_byte:
4227 		case LITERAL_char:
4228 		case LITERAL_short:
4229 		case LITERAL_int:
4230 		case LITERAL_float:
4231 		case LITERAL_long:
4232 		case LITERAL_double:
4233 		case IDENT:
4234 		case LITERAL_private:
4235 		case LITERAL_public:
4236 		case LITERAL_protected:
4237 		case LITERAL_static:
4238 		case LITERAL_transient:
4239 		case LITERAL_native:
4240 		case LITERAL_synchronized:
4241 		case LITERAL_volatile:
4242 		case LITERAL_class:
4243 		case LCURLY:
4244 		case LPAREN:
4245 		case LITERAL_this:
4246 		case LITERAL_super:
4247 		case LITERAL_if:
4248 		case LITERAL_while:
4249 		case LITERAL_do:
4250 		case LITERAL_break:
4251 		case LITERAL_continue:
4252 		case LITERAL_return:
4253 		case LITERAL_switch:
4254 		case LITERAL_throw:
4255 		case LITERAL_for:
4256 		case LITERAL_default:
4257 		case LITERAL_try:
4258 		case PLUS:
4259 		case MINUS:
4260 		case INC:
4261 		case DEC:
4262 		case BNOT:
4263 		case LNOT:
4264 		case LITERAL_true:
4265 		case LITERAL_false:
4266 		case LITERAL_null:
4267 		case LITERAL_new:
4268 		case NUM_INT:
4269 		case CHAR_LITERAL:
4270 		case STRING_LITERAL:
4271 		case NUM_FLOAT:
4272 		case NUM_LONG:
4273 		case NUM_DOUBLE:
4274 		case AT:
4275 		{
4276 			traditionalStatement();
4277 			astFactory.addASTChild(currentAST, returnAST);
4278 			statement_AST = (AST)currentAST.root;
4279 			break;
4280 		}
4281 		case ASSERT:
4282 		{
4283 			assertStatement();
4284 			astFactory.addASTChild(currentAST, returnAST);
4285 			statement_AST = (AST)currentAST.root;
4286 			break;
4287 		}
4288 		default:
4289 		{
4290 			throw new NoViableAltException(LT(1), getFilename());
4291 		}
4292 		}
4293 		returnAST = statement_AST;
4294 	}
4295 	
4296 	public final void primaryExpression() throws RecognitionException, TokenStreamException {
4297 		
4298 		returnAST = null;
4299 		ASTPair currentAST = new ASTPair();
4300 		AST primaryExpression_AST = null;
4301 		Token  lbt = null;
4302 		AST lbt_AST = null;
4303 		
4304 		switch ( LA(1)) {
4305 		case NUM_INT:
4306 		case CHAR_LITERAL:
4307 		case STRING_LITERAL:
4308 		case NUM_FLOAT:
4309 		case NUM_LONG:
4310 		case NUM_DOUBLE:
4311 		{
4312 			constant();
4313 			astFactory.addASTChild(currentAST, returnAST);
4314 			primaryExpression_AST = (AST)currentAST.root;
4315 			break;
4316 		}
4317 		case LITERAL_true:
4318 		{
4319 			AST tmp102_AST = null;
4320 			tmp102_AST = astFactory.create(LT(1));
4321 			astFactory.addASTChild(currentAST, tmp102_AST);
4322 			match(LITERAL_true);
4323 			primaryExpression_AST = (AST)currentAST.root;
4324 			break;
4325 		}
4326 		case LITERAL_false:
4327 		{
4328 			AST tmp103_AST = null;
4329 			tmp103_AST = astFactory.create(LT(1));
4330 			astFactory.addASTChild(currentAST, tmp103_AST);
4331 			match(LITERAL_false);
4332 			primaryExpression_AST = (AST)currentAST.root;
4333 			break;
4334 		}
4335 		case LITERAL_this:
4336 		{
4337 			AST tmp104_AST = null;
4338 			tmp104_AST = astFactory.create(LT(1));
4339 			astFactory.addASTChild(currentAST, tmp104_AST);
4340 			match(LITERAL_this);
4341 			primaryExpression_AST = (AST)currentAST.root;
4342 			break;
4343 		}
4344 		case LITERAL_null:
4345 		{
4346 			AST tmp105_AST = null;
4347 			tmp105_AST = astFactory.create(LT(1));
4348 			astFactory.addASTChild(currentAST, tmp105_AST);
4349 			match(LITERAL_null);
4350 			primaryExpression_AST = (AST)currentAST.root;
4351 			break;
4352 		}
4353 		case LITERAL_new:
4354 		{
4355 			newExpression();
4356 			astFactory.addASTChild(currentAST, returnAST);
4357 			primaryExpression_AST = (AST)currentAST.root;
4358 			break;
4359 		}
4360 		case LPAREN:
4361 		{
4362 			AST tmp106_AST = null;
4363 			tmp106_AST = astFactory.create(LT(1));
4364 			astFactory.addASTChild(currentAST, tmp106_AST);
4365 			match(LPAREN);
4366 			{
4367 			boolean synPredMatched355 = false;
4368 			if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
4369 				int _m355 = mark();
4370 				synPredMatched355 = true;
4371 				inputState.guessing++;
4372 				try {
4373 					{
4374 					lambdaExpression();
4375 					}
4376 				}
4377 				catch (RecognitionException pe) {
4378 					synPredMatched355 = false;
4379 				}
4380 				rewind(_m355);
4381 inputState.guessing--;
4382 			}
4383 			if ( synPredMatched355 ) {
4384 				lambdaExpression();
4385 				astFactory.addASTChild(currentAST, returnAST);
4386 			}
4387 			else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
4388 				assignmentExpression();
4389 				astFactory.addASTChild(currentAST, returnAST);
4390 			}
4391 			else {
4392 				throw new NoViableAltException(LT(1), getFilename());
4393 			}
4394 			
4395 			}
4396 			AST tmp107_AST = null;
4397 			tmp107_AST = astFactory.create(LT(1));
4398 			astFactory.addASTChild(currentAST, tmp107_AST);
4399 			match(RPAREN);
4400 			primaryExpression_AST = (AST)currentAST.root;
4401 			break;
4402 		}
4403 		case LITERAL_super:
4404 		{
4405 			AST tmp108_AST = null;
4406 			tmp108_AST = astFactory.create(LT(1));
4407 			astFactory.addASTChild(currentAST, tmp108_AST);
4408 			match(LITERAL_super);
4409 			primaryExpression_AST = (AST)currentAST.root;
4410 			break;
4411 		}
4412 		default:
4413 			boolean synPredMatched352 = false;
4414 			if (((_tokenSet_9.member(LA(1))) && (_tokenSet_17.member(LA(2))))) {
4415 				int _m352 = mark();
4416 				synPredMatched352 = true;
4417 				inputState.guessing++;
4418 				try {
4419 					{
4420 					typeSpec(false);
4421 					match(DOUBLE_COLON);
4422 					}
4423 				}
4424 				catch (RecognitionException pe) {
4425 					synPredMatched352 = false;
4426 				}
4427 				rewind(_m352);
4428 inputState.guessing--;
4429 			}
4430 			if ( synPredMatched352 ) {
4431 				typeSpec(false);
4432 				astFactory.addASTChild(currentAST, returnAST);
4433 				primaryExpression_AST = (AST)currentAST.root;
4434 			}
4435 			else if ((LA(1)==IDENT) && (_tokenSet_17.member(LA(2)))) {
4436 				AST tmp109_AST = null;
4437 				tmp109_AST = astFactory.create(LT(1));
4438 				astFactory.addASTChild(currentAST, tmp109_AST);
4439 				match(IDENT);
4440 				primaryExpression_AST = (AST)currentAST.root;
4441 			}
4442 			else if (((LA(1) >= LITERAL_void && LA(1) <= LITERAL_double)) && (_tokenSet_17.member(LA(2)))) {
4443 				builtInType();
4444 				astFactory.addASTChild(currentAST, returnAST);
4445 				{
4446 				_loop357:
4447 				do {
4448 					if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
4449 						lbt = LT(1);
4450 						lbt_AST = astFactory.create(lbt);
4451 						astFactory.makeASTRoot(currentAST, lbt_AST);
4452 						match(LBRACK);
4453 						if ( inputState.guessing==0 ) {
4454 							lbt_AST.setType(ARRAY_DECLARATOR);
4455 						}
4456 						AST tmp110_AST = null;
4457 						tmp110_AST = astFactory.create(LT(1));
4458 						astFactory.addASTChild(currentAST, tmp110_AST);
4459 						match(RBRACK);
4460 					}
4461 					else {
4462 						break _loop357;
4463 					}
4464 					
4465 				} while (true);
4466 				}
4467 				{
4468 				if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
4469 					AST tmp111_AST = null;
4470 					tmp111_AST = astFactory.create(LT(1));
4471 					astFactory.makeASTRoot(currentAST, tmp111_AST);
4472 					match(DOT);
4473 					AST tmp112_AST = null;
4474 					tmp112_AST = astFactory.create(LT(1));
4475 					astFactory.addASTChild(currentAST, tmp112_AST);
4476 					match(LITERAL_class);
4477 				}
4478 				else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
4479 				}
4480 				else {
4481 					throw new NoViableAltException(LT(1), getFilename());
4482 				}
4483 				
4484 				}
4485 				primaryExpression_AST = (AST)currentAST.root;
4486 			}
4487 		else {
4488 			throw new NoViableAltException(LT(1), getFilename());
4489 		}
4490 		}
4491 		returnAST = primaryExpression_AST;
4492 	}
4493 	
4494 /** Declaration of a variable.  This can be a class/instance variable,
4495  *   or a local variable in a method.
4496     @param mods declaration mods.
4497     @param t variable declaration type.
4498     @throws RecognitionException if recognition problem occurs.
4499     @throws TokenStreamException if problem occurs while generating a stream of tokens.
4500  * It can also include possible initialization.
4501  */
4502 	public final void variableDeclarator(
4503 		AST mods, AST t
4504 	) throws RecognitionException, TokenStreamException {
4505 		
4506 		returnAST = null;
4507 		ASTPair currentAST = new ASTPair();
4508 		AST variableDeclarator_AST = null;
4509 		Token  id = null;
4510 		AST id_AST = null;
4511 		AST d_AST = null;
4512 		AST v_AST = null;
4513 		
4514 		id = LT(1);
4515 		id_AST = astFactory.create(id);
4516 		match(IDENT);
4517 		declaratorBrackets(t);
4518 		d_AST = (AST)returnAST;
4519 		varInitializer();
4520 		v_AST = (AST)returnAST;
4521 		if ( inputState.guessing==0 ) {
4522 			variableDeclarator_AST = (AST)currentAST.root;
4523 			variableDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST).add(v_AST));
4524 			currentAST.root = variableDeclarator_AST;
4525 			currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ?
4526 				variableDeclarator_AST.getFirstChild() : variableDeclarator_AST;
4527 			currentAST.advanceChildToEnd();
4528 		}
4529 		returnAST = variableDeclarator_AST;
4530 	}
4531 	
4532 	public final void varInitializer() throws RecognitionException, TokenStreamException {
4533 		
4534 		returnAST = null;
4535 		ASTPair currentAST = new ASTPair();
4536 		AST varInitializer_AST = null;
4537 		
4538 		{
4539 		switch ( LA(1)) {
4540 		case ASSIGN:
4541 		{
4542 			AST tmp113_AST = null;
4543 			tmp113_AST = astFactory.create(LT(1));
4544 			astFactory.makeASTRoot(currentAST, tmp113_AST);
4545 			match(ASSIGN);
4546 			initializer();
4547 			astFactory.addASTChild(currentAST, returnAST);
4548 			break;
4549 		}
4550 		case FINAL:
4551 		case ABSTRACT:
4552 		case STRICTFP:
4553 		case SEMI:
4554 		case LITERAL_void:
4555 		case LITERAL_boolean:
4556 		case LITERAL_byte:
4557 		case LITERAL_char:
4558 		case LITERAL_short:
4559 		case LITERAL_int:
4560 		case LITERAL_float:
4561 		case LITERAL_long:
4562 		case LITERAL_double:
4563 		case IDENT:
4564 		case LITERAL_private:
4565 		case LITERAL_public:
4566 		case LITERAL_protected:
4567 		case LITERAL_static:
4568 		case LITERAL_transient:
4569 		case LITERAL_native:
4570 		case LITERAL_synchronized:
4571 		case LITERAL_volatile:
4572 		case LITERAL_class:
4573 		case LITERAL_interface:
4574 		case LCURLY:
4575 		case RCURLY:
4576 		case COMMA:
4577 		case LITERAL_default:
4578 		case LT:
4579 		case ENUM:
4580 		case AT:
4581 		{
4582 			break;
4583 		}
4584 		default:
4585 		{
4586 			throw new NoViableAltException(LT(1), getFilename());
4587 		}
4588 		}
4589 		}
4590 		varInitializer_AST = (AST)currentAST.root;
4591 		returnAST = varInitializer_AST;
4592 	}
4593 	
4594 	public final void initializer() throws RecognitionException, TokenStreamException {
4595 		
4596 		returnAST = null;
4597 		ASTPair currentAST = new ASTPair();
4598 		AST initializer_AST = null;
4599 		
4600 		switch ( LA(1)) {
4601 		case LITERAL_void:
4602 		case LITERAL_boolean:
4603 		case LITERAL_byte:
4604 		case LITERAL_char:
4605 		case LITERAL_short:
4606 		case LITERAL_int:
4607 		case LITERAL_float:
4608 		case LITERAL_long:
4609 		case LITERAL_double:
4610 		case IDENT:
4611 		case LPAREN:
4612 		case LITERAL_this:
4613 		case LITERAL_super:
4614 		case PLUS:
4615 		case MINUS:
4616 		case INC:
4617 		case DEC:
4618 		case BNOT:
4619 		case LNOT:
4620 		case LITERAL_true:
4621 		case LITERAL_false:
4622 		case LITERAL_null:
4623 		case LITERAL_new:
4624 		case NUM_INT:
4625 		case CHAR_LITERAL:
4626 		case STRING_LITERAL:
4627 		case NUM_FLOAT:
4628 		case NUM_LONG:
4629 		case NUM_DOUBLE:
4630 		case AT:
4631 		{
4632 			expression();
4633 			astFactory.addASTChild(currentAST, returnAST);
4634 			initializer_AST = (AST)currentAST.root;
4635 			break;
4636 		}
4637 		case LCURLY:
4638 		{
4639 			arrayInitializer();
4640 			astFactory.addASTChild(currentAST, returnAST);
4641 			initializer_AST = (AST)currentAST.root;
4642 			break;
4643 		}
4644 		default:
4645 		{
4646 			throw new NoViableAltException(LT(1), getFilename());
4647 		}
4648 		}
4649 		returnAST = initializer_AST;
4650 	}
4651 	
4652 	public final void arrayInitializer() throws RecognitionException, TokenStreamException {
4653 		
4654 		returnAST = null;
4655 		ASTPair currentAST = new ASTPair();
4656 		AST arrayInitializer_AST = null;
4657 		Token  lc = null;
4658 		AST lc_AST = null;
4659 		
4660 		lc = LT(1);
4661 		lc_AST = astFactory.create(lc);
4662 		astFactory.makeASTRoot(currentAST, lc_AST);
4663 		match(LCURLY);
4664 		if ( inputState.guessing==0 ) {
4665 			lc_AST.setType(ARRAY_INIT);
4666 		}
4667 		{
4668 		switch ( LA(1)) {
4669 		case LITERAL_void:
4670 		case LITERAL_boolean:
4671 		case LITERAL_byte:
4672 		case LITERAL_char:
4673 		case LITERAL_short:
4674 		case LITERAL_int:
4675 		case LITERAL_float:
4676 		case LITERAL_long:
4677 		case LITERAL_double:
4678 		case IDENT:
4679 		case LCURLY:
4680 		case LPAREN:
4681 		case LITERAL_this:
4682 		case LITERAL_super:
4683 		case PLUS:
4684 		case MINUS:
4685 		case INC:
4686 		case DEC:
4687 		case BNOT:
4688 		case LNOT:
4689 		case LITERAL_true:
4690 		case LITERAL_false:
4691 		case LITERAL_null:
4692 		case LITERAL_new:
4693 		case NUM_INT:
4694 		case CHAR_LITERAL:
4695 		case STRING_LITERAL:
4696 		case NUM_FLOAT:
4697 		case NUM_LONG:
4698 		case NUM_DOUBLE:
4699 		case AT:
4700 		{
4701 			initializer();
4702 			astFactory.addASTChild(currentAST, returnAST);
4703 			{
4704 			_loop175:
4705 			do {
4706 				if ((LA(1)==COMMA) && (_tokenSet_10.member(LA(2)))) {
4707 					AST tmp114_AST = null;
4708 					tmp114_AST = astFactory.create(LT(1));
4709 					astFactory.addASTChild(currentAST, tmp114_AST);
4710 					match(COMMA);
4711 					initializer();
4712 					astFactory.addASTChild(currentAST, returnAST);
4713 				}
4714 				else {
4715 					break _loop175;
4716 				}
4717 				
4718 			} while (true);
4719 			}
4720 			break;
4721 		}
4722 		case RCURLY:
4723 		case COMMA:
4724 		{
4725 			break;
4726 		}
4727 		default:
4728 		{
4729 			throw new NoViableAltException(LT(1), getFilename());
4730 		}
4731 		}
4732 		}
4733 		{
4734 		switch ( LA(1)) {
4735 		case COMMA:
4736 		{
4737 			AST tmp115_AST = null;
4738 			tmp115_AST = astFactory.create(LT(1));
4739 			astFactory.addASTChild(currentAST, tmp115_AST);
4740 			match(COMMA);
4741 			break;
4742 		}
4743 		case RCURLY:
4744 		{
4745 			break;
4746 		}
4747 		default:
4748 		{
4749 			throw new NoViableAltException(LT(1), getFilename());
4750 		}
4751 		}
4752 		}
4753 		AST tmp116_AST = null;
4754 		tmp116_AST = astFactory.create(LT(1));
4755 		astFactory.addASTChild(currentAST, tmp116_AST);
4756 		match(RCURLY);
4757 		arrayInitializer_AST = (AST)currentAST.root;
4758 		returnAST = arrayInitializer_AST;
4759 	}
4760 	
4761 	public final void expression() throws RecognitionException, TokenStreamException {
4762 		
4763 		returnAST = null;
4764 		ASTPair currentAST = new ASTPair();
4765 		AST expression_AST = null;
4766 		
4767 		boolean synPredMatched270 = false;
4768 		if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
4769 			int _m270 = mark();
4770 			synPredMatched270 = true;
4771 			inputState.guessing++;
4772 			try {
4773 				{
4774 				lambdaExpression();
4775 				}
4776 			}
4777 			catch (RecognitionException pe) {
4778 				synPredMatched270 = false;
4779 			}
4780 			rewind(_m270);
4781 inputState.guessing--;
4782 		}
4783 		if ( synPredMatched270 ) {
4784 			lambdaExpression();
4785 			astFactory.addASTChild(currentAST, returnAST);
4786 			expression_AST = (AST)currentAST.root;
4787 		}
4788 		else if (((_tokenSet_12.member(LA(1))) && (_tokenSet_17.member(LA(2))))&&(LA(1)!=RPAREN)) {
4789 			assignmentExpression();
4790 			astFactory.addASTChild(currentAST, returnAST);
4791 			if ( inputState.guessing==0 ) {
4792 				expression_AST = (AST)currentAST.root;
4793 				expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(expression_AST));
4794 				currentAST.root = expression_AST;
4795 				currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ?
4796 					expression_AST.getFirstChild() : expression_AST;
4797 				currentAST.advanceChildToEnd();
4798 			}
4799 			expression_AST = (AST)currentAST.root;
4800 		}
4801 		else {
4802 			throw new NoViableAltException(LT(1), getFilename());
4803 		}
4804 		
4805 		returnAST = expression_AST;
4806 	}
4807 	
4808 	public final void parameterDeclaration() throws RecognitionException, TokenStreamException {
4809 		
4810 		returnAST = null;
4811 		ASTPair currentAST = new ASTPair();
4812 		AST parameterDeclaration_AST = null;
4813 		AST pm_AST = null;
4814 		AST t_AST = null;
4815 		AST id_AST = null;
4816 		AST pd_AST = null;
4817 		
4818 		parameterModifier();
4819 		pm_AST = (AST)returnAST;
4820 		{
4821 		if ((_tokenSet_9.member(LA(1))) && (_tokenSet_47.member(LA(2)))) {
4822 			typeSpec(false);
4823 			t_AST = (AST)returnAST;
4824 		}
4825 		else if ((LA(1)==IDENT||LA(1)==LITERAL_this) && (_tokenSet_48.member(LA(2)))) {
4826 		}
4827 		else {
4828 			throw new NoViableAltException(LT(1), getFilename());
4829 		}
4830 		
4831 		}
4832 		parameterIdent();
4833 		id_AST = (AST)returnAST;
4834 		declaratorBrackets(t_AST);
4835 		pd_AST = (AST)returnAST;
4836 		if ( inputState.guessing==0 ) {
4837 			parameterDeclaration_AST = (AST)currentAST.root;
4838 			parameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(id_AST));
4839 			currentAST.root = parameterDeclaration_AST;
4840 			currentAST.child = parameterDeclaration_AST!=null &&parameterDeclaration_AST.getFirstChild()!=null ?
4841 				parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
4842 			currentAST.advanceChildToEnd();
4843 		}
4844 		returnAST = parameterDeclaration_AST;
4845 	}
4846 	
4847 	public final void variableLengthParameterDeclaration() throws RecognitionException, TokenStreamException {
4848 		
4849 		returnAST = null;
4850 		ASTPair currentAST = new ASTPair();
4851 		AST variableLengthParameterDeclaration_AST = null;
4852 		AST pm_AST = null;
4853 		AST t_AST = null;
4854 		Token  td = null;
4855 		AST td_AST = null;
4856 		AST pd_AST = null;
4857 		
4858 		parameterModifier();
4859 		pm_AST = (AST)returnAST;
4860 		typeSpec(false);
4861 		t_AST = (AST)returnAST;
4862 		td = LT(1);
4863 		td_AST = astFactory.create(td);
4864 		match(ELLIPSIS);
4865 		AST tmp117_AST = null;
4866 		tmp117_AST = astFactory.create(LT(1));
4867 		match(IDENT);
4868 		declaratorBrackets(t_AST);
4869 		pd_AST = (AST)returnAST;
4870 		if ( inputState.guessing==0 ) {
4871 			variableLengthParameterDeclaration_AST = (AST)currentAST.root;
4872 			variableLengthParameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(td_AST).add(tmp117_AST));
4873 			currentAST.root = variableLengthParameterDeclaration_AST;
4874 			currentAST.child = variableLengthParameterDeclaration_AST!=null &&variableLengthParameterDeclaration_AST.getFirstChild()!=null ?
4875 				variableLengthParameterDeclaration_AST.getFirstChild() : variableLengthParameterDeclaration_AST;
4876 			currentAST.advanceChildToEnd();
4877 		}
4878 		returnAST = variableLengthParameterDeclaration_AST;
4879 	}
4880 	
4881 	public final void parameterModifier() throws RecognitionException, TokenStreamException {
4882 		
4883 		returnAST = null;
4884 		ASTPair currentAST = new ASTPair();
4885 		AST parameterModifier_AST = null;
4886 		Token  f = null;
4887 		AST f_AST = null;
4888 		
4889 		{
4890 		_loop197:
4891 		do {
4892 			if ((LA(1)==AT) && (LA(2)==IDENT)) {
4893 				annotation();
4894 				astFactory.addASTChild(currentAST, returnAST);
4895 			}
4896 			else {
4897 				break _loop197;
4898 			}
4899 			
4900 		} while (true);
4901 		}
4902 		{
4903 		switch ( LA(1)) {
4904 		case FINAL:
4905 		{
4906 			f = LT(1);
4907 			f_AST = astFactory.create(f);
4908 			astFactory.addASTChild(currentAST, f_AST);
4909 			match(FINAL);
4910 			break;
4911 		}
4912 		case LITERAL_void:
4913 		case LITERAL_boolean:
4914 		case LITERAL_byte:
4915 		case LITERAL_char:
4916 		case LITERAL_short:
4917 		case LITERAL_int:
4918 		case LITERAL_float:
4919 		case LITERAL_long:
4920 		case LITERAL_double:
4921 		case IDENT:
4922 		case LITERAL_this:
4923 		case AT:
4924 		{
4925 			break;
4926 		}
4927 		default:
4928 		{
4929 			throw new NoViableAltException(LT(1), getFilename());
4930 		}
4931 		}
4932 		}
4933 		{
4934 		_loop200:
4935 		do {
4936 			if ((LA(1)==AT) && (LA(2)==IDENT)) {
4937 				annotation();
4938 				astFactory.addASTChild(currentAST, returnAST);
4939 			}
4940 			else {
4941 				break _loop200;
4942 			}
4943 			
4944 		} while (true);
4945 		}
4946 		if ( inputState.guessing==0 ) {
4947 			parameterModifier_AST = (AST)currentAST.root;
4948 			parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(parameterModifier_AST));
4949 			currentAST.root = parameterModifier_AST;
4950 			currentAST.child = parameterModifier_AST!=null &&parameterModifier_AST.getFirstChild()!=null ?
4951 				parameterModifier_AST.getFirstChild() : parameterModifier_AST;
4952 			currentAST.advanceChildToEnd();
4953 		}
4954 		parameterModifier_AST = (AST)currentAST.root;
4955 		returnAST = parameterModifier_AST;
4956 	}
4957 	
4958 	public final void parameterIdent() throws RecognitionException, TokenStreamException {
4959 		
4960 		returnAST = null;
4961 		ASTPair currentAST = new ASTPair();
4962 		AST parameterIdent_AST = null;
4963 		
4964 		switch ( LA(1)) {
4965 		case LITERAL_this:
4966 		{
4967 			AST tmp118_AST = null;
4968 			tmp118_AST = astFactory.create(LT(1));
4969 			astFactory.addASTChild(currentAST, tmp118_AST);
4970 			match(LITERAL_this);
4971 			parameterIdent_AST = (AST)currentAST.root;
4972 			break;
4973 		}
4974 		case IDENT:
4975 		{
4976 			{
4977 			AST tmp119_AST = null;
4978 			tmp119_AST = astFactory.create(LT(1));
4979 			astFactory.addASTChild(currentAST, tmp119_AST);
4980 			match(IDENT);
4981 			{
4982 			switch ( LA(1)) {
4983 			case DOT:
4984 			{
4985 				AST tmp120_AST = null;
4986 				tmp120_AST = astFactory.create(LT(1));
4987 				astFactory.makeASTRoot(currentAST, tmp120_AST);
4988 				match(DOT);
4989 				AST tmp121_AST = null;
4990 				tmp121_AST = astFactory.create(LT(1));
4991 				astFactory.addASTChild(currentAST, tmp121_AST);
4992 				match(LITERAL_this);
4993 				break;
4994 			}
4995 			case LBRACK:
4996 			case COMMA:
4997 			case RPAREN:
4998 			{
4999 				break;
5000 			}
5001 			default:
5002 			{
5003 				throw new NoViableAltException(LT(1), getFilename());
5004 			}
5005 			}
5006 			}
5007 			}
5008 			parameterIdent_AST = (AST)currentAST.root;
5009 			break;
5010 		}
5011 		default:
5012 		{
5013 			throw new NoViableAltException(LT(1), getFilename());
5014 		}
5015 		}
5016 		returnAST = parameterIdent_AST;
5017 	}
5018 	
5019 	public final void catchParameterDeclaration() throws RecognitionException, TokenStreamException {
5020 		
5021 		returnAST = null;
5022 		ASTPair currentAST = new ASTPair();
5023 		AST catchParameterDeclaration_AST = null;
5024 		AST pm_AST = null;
5025 		AST mct_AST = null;
5026 		Token  id = null;
5027 		AST id_AST = null;
5028 		
5029 		parameterModifier();
5030 		pm_AST = (AST)returnAST;
5031 		multiCatchTypes();
5032 		mct_AST = (AST)returnAST;
5033 		id = LT(1);
5034 		id_AST = astFactory.create(id);
5035 		match(IDENT);
5036 		if ( inputState.guessing==0 ) {
5037 			catchParameterDeclaration_AST = (AST)currentAST.root;
5038 			catchParameterDeclaration_AST =
5039 			(AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(mct_AST))).add(id_AST));
5040 			currentAST.root = catchParameterDeclaration_AST;
5041 			currentAST.child = catchParameterDeclaration_AST!=null &&catchParameterDeclaration_AST.getFirstChild()!=null ?
5042 				catchParameterDeclaration_AST.getFirstChild() : catchParameterDeclaration_AST;
5043 			currentAST.advanceChildToEnd();
5044 		}
5045 		returnAST = catchParameterDeclaration_AST;
5046 	}
5047 	
5048 	public final void multiCatchTypes() throws RecognitionException, TokenStreamException {
5049 		
5050 		returnAST = null;
5051 		ASTPair currentAST = new ASTPair();
5052 		AST multiCatchTypes_AST = null;
5053 		
5054 		typeSpec(false);
5055 		astFactory.addASTChild(currentAST, returnAST);
5056 		{
5057 		_loop209:
5058 		do {
5059 			if ((LA(1)==BOR)) {
5060 				AST tmp122_AST = null;
5061 				tmp122_AST = astFactory.create(LT(1));
5062 				astFactory.makeASTRoot(currentAST, tmp122_AST);
5063 				match(BOR);
5064 				typeSpec(false);
5065 				astFactory.addASTChild(currentAST, returnAST);
5066 			}
5067 			else {
5068 				break _loop209;
5069 			}
5070 			
5071 		} while (true);
5072 		}
5073 		multiCatchTypes_AST = (AST)currentAST.root;
5074 		returnAST = multiCatchTypes_AST;
5075 	}
5076 	
5077 	public final void traditionalStatement() throws RecognitionException, TokenStreamException {
5078 		
5079 		returnAST = null;
5080 		ASTPair currentAST = new ASTPair();
5081 		AST traditionalStatement_AST = null;
5082 		AST m_AST = null;
5083 		Token  c = null;
5084 		AST c_AST = null;
5085 		Token  w = null;
5086 		AST w_AST = null;
5087 		Token  s = null;
5088 		AST s_AST = null;
5089 		
5090 		switch ( LA(1)) {
5091 		case LCURLY:
5092 		{
5093 			compoundStatement();
5094 			astFactory.addASTChild(currentAST, returnAST);
5095 			traditionalStatement_AST = (AST)currentAST.root;
5096 			break;
5097 		}
5098 		case LITERAL_if:
5099 		{
5100 			AST tmp123_AST = null;
5101 			tmp123_AST = astFactory.create(LT(1));
5102 			astFactory.makeASTRoot(currentAST, tmp123_AST);
5103 			match(LITERAL_if);
5104 			AST tmp124_AST = null;
5105 			tmp124_AST = astFactory.create(LT(1));
5106 			astFactory.addASTChild(currentAST, tmp124_AST);
5107 			match(LPAREN);
5108 			expression();
5109 			astFactory.addASTChild(currentAST, returnAST);
5110 			AST tmp125_AST = null;
5111 			tmp125_AST = astFactory.create(LT(1));
5112 			astFactory.addASTChild(currentAST, tmp125_AST);
5113 			match(RPAREN);
5114 			statement();
5115 			astFactory.addASTChild(currentAST, returnAST);
5116 			{
5117 			if ((LA(1)==LITERAL_else) && (_tokenSet_36.member(LA(2)))) {
5118 				elseStatement();
5119 				astFactory.addASTChild(currentAST, returnAST);
5120 			}
5121 			else if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) {
5122 			}
5123 			else {
5124 				throw new NoViableAltException(LT(1), getFilename());
5125 			}
5126 			
5127 			}
5128 			traditionalStatement_AST = (AST)currentAST.root;
5129 			break;
5130 		}
5131 		case LITERAL_for:
5132 		{
5133 			forStatement();
5134 			astFactory.addASTChild(currentAST, returnAST);
5135 			traditionalStatement_AST = (AST)currentAST.root;
5136 			break;
5137 		}
5138 		case LITERAL_while:
5139 		{
5140 			AST tmp126_AST = null;
5141 			tmp126_AST = astFactory.create(LT(1));
5142 			astFactory.makeASTRoot(currentAST, tmp126_AST);
5143 			match(LITERAL_while);
5144 			AST tmp127_AST = null;
5145 			tmp127_AST = astFactory.create(LT(1));
5146 			astFactory.addASTChild(currentAST, tmp127_AST);
5147 			match(LPAREN);
5148 			expression();
5149 			astFactory.addASTChild(currentAST, returnAST);
5150 			AST tmp128_AST = null;
5151 			tmp128_AST = astFactory.create(LT(1));
5152 			astFactory.addASTChild(currentAST, tmp128_AST);
5153 			match(RPAREN);
5154 			statement();
5155 			astFactory.addASTChild(currentAST, returnAST);
5156 			traditionalStatement_AST = (AST)currentAST.root;
5157 			break;
5158 		}
5159 		case LITERAL_do:
5160 		{
5161 			AST tmp129_AST = null;
5162 			tmp129_AST = astFactory.create(LT(1));
5163 			astFactory.makeASTRoot(currentAST, tmp129_AST);
5164 			match(LITERAL_do);
5165 			statement();
5166 			astFactory.addASTChild(currentAST, returnAST);
5167 			w = LT(1);
5168 			w_AST = astFactory.create(w);
5169 			astFactory.addASTChild(currentAST, w_AST);
5170 			match(LITERAL_while);
5171 			if ( inputState.guessing==0 ) {
5172 				w_AST.setType(DO_WHILE);
5173 			}
5174 			AST tmp130_AST = null;
5175 			tmp130_AST = astFactory.create(LT(1));
5176 			astFactory.addASTChild(currentAST, tmp130_AST);
5177 			match(LPAREN);
5178 			expression();
5179 			astFactory.addASTChild(currentAST, returnAST);
5180 			AST tmp131_AST = null;
5181 			tmp131_AST = astFactory.create(LT(1));
5182 			astFactory.addASTChild(currentAST, tmp131_AST);
5183 			match(RPAREN);
5184 			AST tmp132_AST = null;
5185 			tmp132_AST = astFactory.create(LT(1));
5186 			astFactory.addASTChild(currentAST, tmp132_AST);
5187 			match(SEMI);
5188 			traditionalStatement_AST = (AST)currentAST.root;
5189 			break;
5190 		}
5191 		case LITERAL_break:
5192 		{
5193 			AST tmp133_AST = null;
5194 			tmp133_AST = astFactory.create(LT(1));
5195 			astFactory.makeASTRoot(currentAST, tmp133_AST);
5196 			match(LITERAL_break);
5197 			{
5198 			switch ( LA(1)) {
5199 			case IDENT:
5200 			{
5201 				AST tmp134_AST = null;
5202 				tmp134_AST = astFactory.create(LT(1));
5203 				astFactory.addASTChild(currentAST, tmp134_AST);
5204 				match(IDENT);
5205 				break;
5206 			}
5207 			case SEMI:
5208 			{
5209 				break;
5210 			}
5211 			default:
5212 			{
5213 				throw new NoViableAltException(LT(1), getFilename());
5214 			}
5215 			}
5216 			}
5217 			AST tmp135_AST = null;
5218 			tmp135_AST = astFactory.create(LT(1));
5219 			astFactory.addASTChild(currentAST, tmp135_AST);
5220 			match(SEMI);
5221 			traditionalStatement_AST = (AST)currentAST.root;
5222 			break;
5223 		}
5224 		case LITERAL_continue:
5225 		{
5226 			AST tmp136_AST = null;
5227 			tmp136_AST = astFactory.create(LT(1));
5228 			astFactory.makeASTRoot(currentAST, tmp136_AST);
5229 			match(LITERAL_continue);
5230 			{
5231 			switch ( LA(1)) {
5232 			case IDENT:
5233 			{
5234 				AST tmp137_AST = null;
5235 				tmp137_AST = astFactory.create(LT(1));
5236 				astFactory.addASTChild(currentAST, tmp137_AST);
5237 				match(IDENT);
5238 				break;
5239 			}
5240 			case SEMI:
5241 			{
5242 				break;
5243 			}
5244 			default:
5245 			{
5246 				throw new NoViableAltException(LT(1), getFilename());
5247 			}
5248 			}
5249 			}
5250 			AST tmp138_AST = null;
5251 			tmp138_AST = astFactory.create(LT(1));
5252 			astFactory.addASTChild(currentAST, tmp138_AST);
5253 			match(SEMI);
5254 			traditionalStatement_AST = (AST)currentAST.root;
5255 			break;
5256 		}
5257 		case LITERAL_return:
5258 		{
5259 			AST tmp139_AST = null;
5260 			tmp139_AST = astFactory.create(LT(1));
5261 			astFactory.makeASTRoot(currentAST, tmp139_AST);
5262 			match(LITERAL_return);
5263 			{
5264 			switch ( LA(1)) {
5265 			case LITERAL_void:
5266 			case LITERAL_boolean:
5267 			case LITERAL_byte:
5268 			case LITERAL_char:
5269 			case LITERAL_short:
5270 			case LITERAL_int:
5271 			case LITERAL_float:
5272 			case LITERAL_long:
5273 			case LITERAL_double:
5274 			case IDENT:
5275 			case LPAREN:
5276 			case LITERAL_this:
5277 			case LITERAL_super:
5278 			case PLUS:
5279 			case MINUS:
5280 			case INC:
5281 			case DEC:
5282 			case BNOT:
5283 			case LNOT:
5284 			case LITERAL_true:
5285 			case LITERAL_false:
5286 			case LITERAL_null:
5287 			case LITERAL_new:
5288 			case NUM_INT:
5289 			case CHAR_LITERAL:
5290 			case STRING_LITERAL:
5291 			case NUM_FLOAT:
5292 			case NUM_LONG:
5293 			case NUM_DOUBLE:
5294 			case AT:
5295 			{
5296 				expression();
5297 				astFactory.addASTChild(currentAST, returnAST);
5298 				break;
5299 			}
5300 			case SEMI:
5301 			{
5302 				break;
5303 			}
5304 			default:
5305 			{
5306 				throw new NoViableAltException(LT(1), getFilename());
5307 			}
5308 			}
5309 			}
5310 			AST tmp140_AST = null;
5311 			tmp140_AST = astFactory.create(LT(1));
5312 			astFactory.addASTChild(currentAST, tmp140_AST);
5313 			match(SEMI);
5314 			traditionalStatement_AST = (AST)currentAST.root;
5315 			break;
5316 		}
5317 		case LITERAL_switch:
5318 		{
5319 			AST tmp141_AST = null;
5320 			tmp141_AST = astFactory.create(LT(1));
5321 			astFactory.makeASTRoot(currentAST, tmp141_AST);
5322 			match(LITERAL_switch);
5323 			AST tmp142_AST = null;
5324 			tmp142_AST = astFactory.create(LT(1));
5325 			astFactory.addASTChild(currentAST, tmp142_AST);
5326 			match(LPAREN);
5327 			expression();
5328 			astFactory.addASTChild(currentAST, returnAST);
5329 			AST tmp143_AST = null;
5330 			tmp143_AST = astFactory.create(LT(1));
5331 			astFactory.addASTChild(currentAST, tmp143_AST);
5332 			match(RPAREN);
5333 			AST tmp144_AST = null;
5334 			tmp144_AST = astFactory.create(LT(1));
5335 			astFactory.addASTChild(currentAST, tmp144_AST);
5336 			match(LCURLY);
5337 			{
5338 			_loop228:
5339 			do {
5340 				if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) {
5341 					casesGroup();
5342 					astFactory.addASTChild(currentAST, returnAST);
5343 				}
5344 				else {
5345 					break _loop228;
5346 				}
5347 				
5348 			} while (true);
5349 			}
5350 			AST tmp145_AST = null;
5351 			tmp145_AST = astFactory.create(LT(1));
5352 			astFactory.addASTChild(currentAST, tmp145_AST);
5353 			match(RCURLY);
5354 			traditionalStatement_AST = (AST)currentAST.root;
5355 			break;
5356 		}
5357 		case LITERAL_try:
5358 		{
5359 			tryBlock();
5360 			astFactory.addASTChild(currentAST, returnAST);
5361 			traditionalStatement_AST = (AST)currentAST.root;
5362 			break;
5363 		}
5364 		case LITERAL_throw:
5365 		{
5366 			AST tmp146_AST = null;
5367 			tmp146_AST = astFactory.create(LT(1));
5368 			astFactory.makeASTRoot(currentAST, tmp146_AST);
5369 			match(LITERAL_throw);
5370 			expression();
5371 			astFactory.addASTChild(currentAST, returnAST);
5372 			AST tmp147_AST = null;
5373 			tmp147_AST = astFactory.create(LT(1));
5374 			astFactory.addASTChild(currentAST, tmp147_AST);
5375 			match(SEMI);
5376 			traditionalStatement_AST = (AST)currentAST.root;
5377 			break;
5378 		}
5379 		case SEMI:
5380 		{
5381 			s = LT(1);
5382 			s_AST = astFactory.create(s);
5383 			astFactory.addASTChild(currentAST, s_AST);
5384 			match(SEMI);
5385 			if ( inputState.guessing==0 ) {
5386 				s_AST.setType(EMPTY_STAT);
5387 			}
5388 			traditionalStatement_AST = (AST)currentAST.root;
5389 			break;
5390 		}
5391 		default:
5392 			boolean synPredMatched218 = false;
5393 			if (((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2))))) {
5394 				int _m218 = mark();
5395 				synPredMatched218 = true;
5396 				inputState.guessing++;
5397 				try {
5398 					{
5399 					declaration();
5400 					}
5401 				}
5402 				catch (RecognitionException pe) {
5403 					synPredMatched218 = false;
5404 				}
5405 				rewind(_m218);
5406 inputState.guessing--;
5407 			}
5408 			if ( synPredMatched218 ) {
5409 				declaration();
5410 				astFactory.addASTChild(currentAST, returnAST);
5411 				AST tmp148_AST = null;
5412 				tmp148_AST = astFactory.create(LT(1));
5413 				astFactory.addASTChild(currentAST, tmp148_AST);
5414 				match(SEMI);
5415 				traditionalStatement_AST = (AST)currentAST.root;
5416 			}
5417 			else {
5418 				boolean synPredMatched221 = false;
5419 				if ((((_tokenSet_12.member(LA(1))) && (_tokenSet_53.member(LA(2))))&&(LA(2) != COLON))) {
5420 					int _m221 = mark();
5421 					synPredMatched221 = true;
5422 					inputState.guessing++;
5423 					try {
5424 						{
5425 						if (!(LA(2) != COLON))
5426 						  throw new SemanticException("LA(2) != COLON");
5427 						expression();
5428 						{
5429 						if ((LA(1)==SEMI)) {
5430 							match(SEMI);
5431 						}
5432 						else {
5433 						}
5434 						
5435 						}
5436 						}
5437 					}
5438 					catch (RecognitionException pe) {
5439 						synPredMatched221 = false;
5440 					}
5441 					rewind(_m221);
5442 inputState.guessing--;
5443 				}
5444 				if ( synPredMatched221 ) {
5445 					expression();
5446 					astFactory.addASTChild(currentAST, returnAST);
5447 					{
5448 					if ((LA(1)==SEMI) && (_tokenSet_49.member(LA(2)))) {
5449 						AST tmp149_AST = null;
5450 						tmp149_AST = astFactory.create(LT(1));
5451 						astFactory.addASTChild(currentAST, tmp149_AST);
5452 						match(SEMI);
5453 					}
5454 					else if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) {
5455 					}
5456 					else {
5457 						throw new NoViableAltException(LT(1), getFilename());
5458 					}
5459 					
5460 					}
5461 					traditionalStatement_AST = (AST)currentAST.root;
5462 				}
5463 				else if ((_tokenSet_54.member(LA(1))) && (_tokenSet_55.member(LA(2)))) {
5464 					modifiers();
5465 					m_AST = (AST)returnAST;
5466 					classDefinition(m_AST);
5467 					astFactory.addASTChild(currentAST, returnAST);
5468 					traditionalStatement_AST = (AST)currentAST.root;
5469 				}
5470 				else if ((LA(1)==IDENT) && (LA(2)==COLON)) {
5471 					AST tmp150_AST = null;
5472 					tmp150_AST = astFactory.create(LT(1));
5473 					astFactory.addASTChild(currentAST, tmp150_AST);
5474 					match(IDENT);
5475 					c = LT(1);
5476 					c_AST = astFactory.create(c);
5477 					astFactory.makeASTRoot(currentAST, c_AST);
5478 					match(COLON);
5479 					if ( inputState.guessing==0 ) {
5480 						c_AST.setType(LABELED_STAT);
5481 					}
5482 					statement();
5483 					astFactory.addASTChild(currentAST, returnAST);
5484 					traditionalStatement_AST = (AST)currentAST.root;
5485 				}
5486 				else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) {
5487 					AST tmp151_AST = null;
5488 					tmp151_AST = astFactory.create(LT(1));
5489 					astFactory.makeASTRoot(currentAST, tmp151_AST);
5490 					match(LITERAL_synchronized);
5491 					AST tmp152_AST = null;
5492 					tmp152_AST = astFactory.create(LT(1));
5493 					astFactory.addASTChild(currentAST, tmp152_AST);
5494 					match(LPAREN);
5495 					expression();
5496 					astFactory.addASTChild(currentAST, returnAST);
5497 					AST tmp153_AST = null;
5498 					tmp153_AST = astFactory.create(LT(1));
5499 					astFactory.addASTChild(currentAST, tmp153_AST);
5500 					match(RPAREN);
5501 					compoundStatement();
5502 					astFactory.addASTChild(currentAST, returnAST);
5503 					traditionalStatement_AST = (AST)currentAST.root;
5504 				}
5505 			else {
5506 				throw new NoViableAltException(LT(1), getFilename());
5507 			}
5508 			}}
5509 			returnAST = traditionalStatement_AST;
5510 		}
5511 		
5512 	public final void assertStatement() throws RecognitionException, TokenStreamException {
5513 		
5514 		returnAST = null;
5515 		ASTPair currentAST = new ASTPair();
5516 		AST assertStatement_AST = null;
5517 		
5518 		AST tmp154_AST = null;
5519 		tmp154_AST = astFactory.create(LT(1));
5520 		astFactory.makeASTRoot(currentAST, tmp154_AST);
5521 		match(ASSERT);
5522 		expression();
5523 		astFactory.addASTChild(currentAST, returnAST);
5524 		{
5525 		switch ( LA(1)) {
5526 		case COLON:
5527 		{
5528 			AST tmp155_AST = null;
5529 			tmp155_AST = astFactory.create(LT(1));
5530 			astFactory.addASTChild(currentAST, tmp155_AST);
5531 			match(COLON);
5532 			expression();
5533 			astFactory.addASTChild(currentAST, returnAST);
5534 			break;
5535 		}
5536 		case SEMI:
5537 		{
5538 			break;
5539 		}
5540 		default:
5541 		{
5542 			throw new NoViableAltException(LT(1), getFilename());
5543 		}
5544 		}
5545 		}
5546 		AST tmp156_AST = null;
5547 		tmp156_AST = astFactory.create(LT(1));
5548 		astFactory.addASTChild(currentAST, tmp156_AST);
5549 		match(SEMI);
5550 		assertStatement_AST = (AST)currentAST.root;
5551 		returnAST = assertStatement_AST;
5552 	}
5553 	
5554 	public final void elseStatement() throws RecognitionException, TokenStreamException {
5555 		
5556 		returnAST = null;
5557 		ASTPair currentAST = new ASTPair();
5558 		AST elseStatement_AST = null;
5559 		
5560 		AST tmp157_AST = null;
5561 		tmp157_AST = astFactory.create(LT(1));
5562 		astFactory.makeASTRoot(currentAST, tmp157_AST);
5563 		match(LITERAL_else);
5564 		statement();
5565 		astFactory.addASTChild(currentAST, returnAST);
5566 		elseStatement_AST = (AST)currentAST.root;
5567 		returnAST = elseStatement_AST;
5568 	}
5569 	
5570 	public final void forStatement() throws RecognitionException, TokenStreamException {
5571 		
5572 		returnAST = null;
5573 		ASTPair currentAST = new ASTPair();
5574 		AST forStatement_AST = null;
5575 		Token  f = null;
5576 		AST f_AST = null;
5577 		
5578 		f = LT(1);
5579 		f_AST = astFactory.create(f);
5580 		astFactory.makeASTRoot(currentAST, f_AST);
5581 		match(LITERAL_for);
5582 		AST tmp158_AST = null;
5583 		tmp158_AST = astFactory.create(LT(1));
5584 		astFactory.addASTChild(currentAST, tmp158_AST);
5585 		match(LPAREN);
5586 		{
5587 		boolean synPredMatched232 = false;
5588 		if (((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2))))) {
5589 			int _m232 = mark();
5590 			synPredMatched232 = true;
5591 			inputState.guessing++;
5592 			try {
5593 				{
5594 				forInit();
5595 				match(SEMI);
5596 				}
5597 			}
5598 			catch (RecognitionException pe) {
5599 				synPredMatched232 = false;
5600 			}
5601 			rewind(_m232);
5602 inputState.guessing--;
5603 		}
5604 		if ( synPredMatched232 ) {
5605 			traditionalForClause();
5606 			astFactory.addASTChild(currentAST, returnAST);
5607 		}
5608 		else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
5609 			forEachClause();
5610 			astFactory.addASTChild(currentAST, returnAST);
5611 		}
5612 		else {
5613 			throw new NoViableAltException(LT(1), getFilename());
5614 		}
5615 		
5616 		}
5617 		AST tmp159_AST = null;
5618 		tmp159_AST = astFactory.create(LT(1));
5619 		astFactory.addASTChild(currentAST, tmp159_AST);
5620 		match(RPAREN);
5621 		statement();
5622 		astFactory.addASTChild(currentAST, returnAST);
5623 		forStatement_AST = (AST)currentAST.root;
5624 		returnAST = forStatement_AST;
5625 	}
5626 	
5627 	public final void casesGroup() throws RecognitionException, TokenStreamException {
5628 		
5629 		returnAST = null;
5630 		ASTPair currentAST = new ASTPair();
5631 		AST casesGroup_AST = null;
5632 		
5633 		{
5634 		int _cnt239=0;
5635 		_loop239:
5636 		do {
5637 			if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_58.member(LA(2)))) {
5638 				aCase();
5639 				astFactory.addASTChild(currentAST, returnAST);
5640 			}
5641 			else {
5642 				if ( _cnt239>=1 ) { break _loop239; } else {throw new NoViableAltException(LT(1), getFilename());}
5643 			}
5644 			
5645 			_cnt239++;
5646 		} while (true);
5647 		}
5648 		{
5649 		if ((_tokenSet_36.member(LA(1))) && (_tokenSet_59.member(LA(2)))) {
5650 			caseSList();
5651 			astFactory.addASTChild(currentAST, returnAST);
5652 		}
5653 		else if ((_tokenSet_60.member(LA(1))) && (_tokenSet_49.member(LA(2)))) {
5654 		}
5655 		else {
5656 			throw new NoViableAltException(LT(1), getFilename());
5657 		}
5658 		
5659 		}
5660 		if ( inputState.guessing==0 ) {
5661 			casesGroup_AST = (AST)currentAST.root;
5662 			casesGroup_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CASE_GROUP,"CASE_GROUP")).add(casesGroup_AST));
5663 			currentAST.root = casesGroup_AST;
5664 			currentAST.child = casesGroup_AST!=null &&casesGroup_AST.getFirstChild()!=null ?
5665 				casesGroup_AST.getFirstChild() : casesGroup_AST;
5666 			currentAST.advanceChildToEnd();
5667 		}
5668 		casesGroup_AST = (AST)currentAST.root;
5669 		returnAST = casesGroup_AST;
5670 	}
5671 	
5672 	public final void tryBlock() throws RecognitionException, TokenStreamException {
5673 		
5674 		returnAST = null;
5675 		ASTPair currentAST = new ASTPair();
5676 		AST tryBlock_AST = null;
5677 		
5678 		AST tmp160_AST = null;
5679 		tmp160_AST = astFactory.create(LT(1));
5680 		astFactory.makeASTRoot(currentAST, tmp160_AST);
5681 		match(LITERAL_try);
5682 		{
5683 		switch ( LA(1)) {
5684 		case LPAREN:
5685 		{
5686 			resourceSpecification();
5687 			astFactory.addASTChild(currentAST, returnAST);
5688 			break;
5689 		}
5690 		case LCURLY:
5691 		{
5692 			break;
5693 		}
5694 		default:
5695 		{
5696 			throw new NoViableAltException(LT(1), getFilename());
5697 		}
5698 		}
5699 		}
5700 		compoundStatement();
5701 		astFactory.addASTChild(currentAST, returnAST);
5702 		{
5703 		_loop257:
5704 		do {
5705 			if ((LA(1)==LITERAL_catch)) {
5706 				handler();
5707 				astFactory.addASTChild(currentAST, returnAST);
5708 			}
5709 			else {
5710 				break _loop257;
5711 			}
5712 			
5713 		} while (true);
5714 		}
5715 		{
5716 		switch ( LA(1)) {
5717 		case LITERAL_finally:
5718 		{
5719 			finallyHandler();
5720 			astFactory.addASTChild(currentAST, returnAST);
5721 			break;
5722 		}
5723 		case FINAL:
5724 		case ABSTRACT:
5725 		case STRICTFP:
5726 		case SEMI:
5727 		case LITERAL_void:
5728 		case LITERAL_boolean:
5729 		case LITERAL_byte:
5730 		case LITERAL_char:
5731 		case LITERAL_short:
5732 		case LITERAL_int:
5733 		case LITERAL_float:
5734 		case LITERAL_long:
5735 		case LITERAL_double:
5736 		case IDENT:
5737 		case STAR:
5738 		case LITERAL_private:
5739 		case LITERAL_public:
5740 		case LITERAL_protected:
5741 		case LITERAL_static:
5742 		case LITERAL_transient:
5743 		case LITERAL_native:
5744 		case LITERAL_synchronized:
5745 		case LITERAL_volatile:
5746 		case LITERAL_class:
5747 		case LCURLY:
5748 		case RCURLY:
5749 		case LPAREN:
5750 		case RPAREN:
5751 		case LITERAL_this:
5752 		case LITERAL_super:
5753 		case COLON:
5754 		case LITERAL_if:
5755 		case LITERAL_while:
5756 		case LITERAL_do:
5757 		case LITERAL_break:
5758 		case LITERAL_continue:
5759 		case LITERAL_return:
5760 		case LITERAL_switch:
5761 		case LITERAL_throw:
5762 		case LITERAL_for:
5763 		case LITERAL_else:
5764 		case LITERAL_case:
5765 		case LITERAL_default:
5766 		case LITERAL_try:
5767 		case LT:
5768 		case GT:
5769 		case LE:
5770 		case GE:
5771 		case LITERAL_instanceof:
5772 		case SL:
5773 		case SR:
5774 		case BSR:
5775 		case PLUS:
5776 		case MINUS:
5777 		case DIV:
5778 		case MOD:
5779 		case INC:
5780 		case DEC:
5781 		case BNOT:
5782 		case LNOT:
5783 		case LITERAL_true:
5784 		case LITERAL_false:
5785 		case LITERAL_null:
5786 		case LITERAL_new:
5787 		case NUM_INT:
5788 		case CHAR_LITERAL:
5789 		case STRING_LITERAL:
5790 		case NUM_FLOAT:
5791 		case NUM_LONG:
5792 		case NUM_DOUBLE:
5793 		case ASSERT:
5794 		case AT:
5795 		{
5796 			break;
5797 		}
5798 		default:
5799 		{
5800 			throw new NoViableAltException(LT(1), getFilename());
5801 		}
5802 		}
5803 		}
5804 		tryBlock_AST = (AST)currentAST.root;
5805 		returnAST = tryBlock_AST;
5806 	}
5807 	
5808 	public final void forInit() throws RecognitionException, TokenStreamException {
5809 		
5810 		returnAST = null;
5811 		ASTPair currentAST = new ASTPair();
5812 		AST forInit_AST = null;
5813 		
5814 		{
5815 		boolean synPredMatched249 = false;
5816 		if (((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2))))) {
5817 			int _m249 = mark();
5818 			synPredMatched249 = true;
5819 			inputState.guessing++;
5820 			try {
5821 				{
5822 				declaration();
5823 				}
5824 			}
5825 			catch (RecognitionException pe) {
5826 				synPredMatched249 = false;
5827 			}
5828 			rewind(_m249);
5829 inputState.guessing--;
5830 		}
5831 		if ( synPredMatched249 ) {
5832 			declaration();
5833 			astFactory.addASTChild(currentAST, returnAST);
5834 		}
5835 		else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_61.member(LA(2)))) {
5836 			expressionList();
5837 			astFactory.addASTChild(currentAST, returnAST);
5838 		}
5839 		else if ((LA(1)==SEMI)) {
5840 		}
5841 		else {
5842 			throw new NoViableAltException(LT(1), getFilename());
5843 		}
5844 		
5845 		}
5846 		if ( inputState.guessing==0 ) {
5847 			forInit_AST = (AST)currentAST.root;
5848 			forInit_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_INIT,"FOR_INIT")).add(forInit_AST));
5849 			currentAST.root = forInit_AST;
5850 			currentAST.child = forInit_AST!=null &&forInit_AST.getFirstChild()!=null ?
5851 				forInit_AST.getFirstChild() : forInit_AST;
5852 			currentAST.advanceChildToEnd();
5853 		}
5854 		forInit_AST = (AST)currentAST.root;
5855 		returnAST = forInit_AST;
5856 	}
5857 	
5858 	public final void traditionalForClause() throws RecognitionException, TokenStreamException {
5859 		
5860 		returnAST = null;
5861 		ASTPair currentAST = new ASTPair();
5862 		AST traditionalForClause_AST = null;
5863 		
5864 		forInit();
5865 		astFactory.addASTChild(currentAST, returnAST);
5866 		AST tmp161_AST = null;
5867 		tmp161_AST = astFactory.create(LT(1));
5868 		astFactory.addASTChild(currentAST, tmp161_AST);
5869 		match(SEMI);
5870 		forCond();
5871 		astFactory.addASTChild(currentAST, returnAST);
5872 		AST tmp162_AST = null;
5873 		tmp162_AST = astFactory.create(LT(1));
5874 		astFactory.addASTChild(currentAST, tmp162_AST);
5875 		match(SEMI);
5876 		forIter();
5877 		astFactory.addASTChild(currentAST, returnAST);
5878 		traditionalForClause_AST = (AST)currentAST.root;
5879 		returnAST = traditionalForClause_AST;
5880 	}
5881 	
5882 	public final void forEachClause() throws RecognitionException, TokenStreamException {
5883 		
5884 		returnAST = null;
5885 		ASTPair currentAST = new ASTPair();
5886 		AST forEachClause_AST = null;
5887 		
5888 		forEachDeclarator();
5889 		astFactory.addASTChild(currentAST, returnAST);
5890 		AST tmp163_AST = null;
5891 		tmp163_AST = astFactory.create(LT(1));
5892 		astFactory.addASTChild(currentAST, tmp163_AST);
5893 		match(COLON);
5894 		expression();
5895 		astFactory.addASTChild(currentAST, returnAST);
5896 		if ( inputState.guessing==0 ) {
5897 			forEachClause_AST = (AST)currentAST.root;
5898 			forEachClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE")).add(forEachClause_AST));
5899 			currentAST.root = forEachClause_AST;
5900 			currentAST.child = forEachClause_AST!=null &&forEachClause_AST.getFirstChild()!=null ?
5901 				forEachClause_AST.getFirstChild() : forEachClause_AST;
5902 			currentAST.advanceChildToEnd();
5903 		}
5904 		forEachClause_AST = (AST)currentAST.root;
5905 		returnAST = forEachClause_AST;
5906 	}
5907 	
5908 	public final void forCond() throws RecognitionException, TokenStreamException {
5909 		
5910 		returnAST = null;
5911 		ASTPair currentAST = new ASTPair();
5912 		AST forCond_AST = null;
5913 		
5914 		{
5915 		switch ( LA(1)) {
5916 		case LITERAL_void:
5917 		case LITERAL_boolean:
5918 		case LITERAL_byte:
5919 		case LITERAL_char:
5920 		case LITERAL_short:
5921 		case LITERAL_int:
5922 		case LITERAL_float:
5923 		case LITERAL_long:
5924 		case LITERAL_double:
5925 		case IDENT:
5926 		case LPAREN:
5927 		case LITERAL_this:
5928 		case LITERAL_super:
5929 		case PLUS:
5930 		case MINUS:
5931 		case INC:
5932 		case DEC:
5933 		case BNOT:
5934 		case LNOT:
5935 		case LITERAL_true:
5936 		case LITERAL_false:
5937 		case LITERAL_null:
5938 		case LITERAL_new:
5939 		case NUM_INT:
5940 		case CHAR_LITERAL:
5941 		case STRING_LITERAL:
5942 		case NUM_FLOAT:
5943 		case NUM_LONG:
5944 		case NUM_DOUBLE:
5945 		case AT:
5946 		{
5947 			expression();
5948 			astFactory.addASTChild(currentAST, returnAST);
5949 			break;
5950 		}
5951 		case SEMI:
5952 		{
5953 			break;
5954 		}
5955 		default:
5956 		{
5957 			throw new NoViableAltException(LT(1), getFilename());
5958 		}
5959 		}
5960 		}
5961 		if ( inputState.guessing==0 ) {
5962 			forCond_AST = (AST)currentAST.root;
5963 			forCond_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_CONDITION,"FOR_CONDITION")).add(forCond_AST));
5964 			currentAST.root = forCond_AST;
5965 			currentAST.child = forCond_AST!=null &&forCond_AST.getFirstChild()!=null ?
5966 				forCond_AST.getFirstChild() : forCond_AST;
5967 			currentAST.advanceChildToEnd();
5968 		}
5969 		forCond_AST = (AST)currentAST.root;
5970 		returnAST = forCond_AST;
5971 	}
5972 	
5973 	public final void forIter() throws RecognitionException, TokenStreamException {
5974 		
5975 		returnAST = null;
5976 		ASTPair currentAST = new ASTPair();
5977 		AST forIter_AST = null;
5978 		
5979 		{
5980 		switch ( LA(1)) {
5981 		case LITERAL_void:
5982 		case LITERAL_boolean:
5983 		case LITERAL_byte:
5984 		case LITERAL_char:
5985 		case LITERAL_short:
5986 		case LITERAL_int:
5987 		case LITERAL_float:
5988 		case LITERAL_long:
5989 		case LITERAL_double:
5990 		case IDENT:
5991 		case LPAREN:
5992 		case LITERAL_this:
5993 		case LITERAL_super:
5994 		case PLUS:
5995 		case MINUS:
5996 		case INC:
5997 		case DEC:
5998 		case BNOT:
5999 		case LNOT:
6000 		case LITERAL_true:
6001 		case LITERAL_false:
6002 		case LITERAL_null:
6003 		case LITERAL_new:
6004 		case NUM_INT:
6005 		case CHAR_LITERAL:
6006 		case STRING_LITERAL:
6007 		case NUM_FLOAT:
6008 		case NUM_LONG:
6009 		case NUM_DOUBLE:
6010 		case AT:
6011 		{
6012 			expressionList();
6013 			astFactory.addASTChild(currentAST, returnAST);
6014 			break;
6015 		}
6016 		case RPAREN:
6017 		{
6018 			break;
6019 		}
6020 		default:
6021 		{
6022 			throw new NoViableAltException(LT(1), getFilename());
6023 		}
6024 		}
6025 		}
6026 		if ( inputState.guessing==0 ) {
6027 			forIter_AST = (AST)currentAST.root;
6028 			forIter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_ITERATOR,"FOR_ITERATOR")).add(forIter_AST));
6029 			currentAST.root = forIter_AST;
6030 			currentAST.child = forIter_AST!=null &&forIter_AST.getFirstChild()!=null ?
6031 				forIter_AST.getFirstChild() : forIter_AST;
6032 			currentAST.advanceChildToEnd();
6033 		}
6034 		forIter_AST = (AST)currentAST.root;
6035 		returnAST = forIter_AST;
6036 	}
6037 	
6038 	public final void forEachDeclarator() throws RecognitionException, TokenStreamException {
6039 		
6040 		returnAST = null;
6041 		ASTPair currentAST = new ASTPair();
6042 		AST forEachDeclarator_AST = null;
6043 		AST m_AST = null;
6044 		AST t_AST = null;
6045 		Token  id = null;
6046 		AST id_AST = null;
6047 		AST d_AST = null;
6048 		
6049 		modifiers();
6050 		m_AST = (AST)returnAST;
6051 		typeSpec(false);
6052 		t_AST = (AST)returnAST;
6053 		id = LT(1);
6054 		id_AST = astFactory.create(id);
6055 		match(IDENT);
6056 		declaratorBrackets(t_AST);
6057 		d_AST = (AST)returnAST;
6058 		if ( inputState.guessing==0 ) {
6059 			forEachDeclarator_AST = (AST)currentAST.root;
6060 			forEachDeclarator_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(m_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST));
6061 			currentAST.root = forEachDeclarator_AST;
6062 			currentAST.child = forEachDeclarator_AST!=null &&forEachDeclarator_AST.getFirstChild()!=null ?
6063 				forEachDeclarator_AST.getFirstChild() : forEachDeclarator_AST;
6064 			currentAST.advanceChildToEnd();
6065 		}
6066 		returnAST = forEachDeclarator_AST;
6067 	}
6068 	
6069 	public final void aCase() throws RecognitionException, TokenStreamException {
6070 		
6071 		returnAST = null;
6072 		ASTPair currentAST = new ASTPair();
6073 		AST aCase_AST = null;
6074 		
6075 		{
6076 		switch ( LA(1)) {
6077 		case LITERAL_case:
6078 		{
6079 			AST tmp164_AST = null;
6080 			tmp164_AST = astFactory.create(LT(1));
6081 			astFactory.makeASTRoot(currentAST, tmp164_AST);
6082 			match(LITERAL_case);
6083 			expression();
6084 			astFactory.addASTChild(currentAST, returnAST);
6085 			break;
6086 		}
6087 		case LITERAL_default:
6088 		{
6089 			AST tmp165_AST = null;
6090 			tmp165_AST = astFactory.create(LT(1));
6091 			astFactory.makeASTRoot(currentAST, tmp165_AST);
6092 			match(LITERAL_default);
6093 			break;
6094 		}
6095 		default:
6096 		{
6097 			throw new NoViableAltException(LT(1), getFilename());
6098 		}
6099 		}
6100 		}
6101 		AST tmp166_AST = null;
6102 		tmp166_AST = astFactory.create(LT(1));
6103 		astFactory.addASTChild(currentAST, tmp166_AST);
6104 		match(COLON);
6105 		aCase_AST = (AST)currentAST.root;
6106 		returnAST = aCase_AST;
6107 	}
6108 	
6109 	public final void caseSList() throws RecognitionException, TokenStreamException {
6110 		
6111 		returnAST = null;
6112 		ASTPair currentAST = new ASTPair();
6113 		AST caseSList_AST = null;
6114 		
6115 		{
6116 		int _cnt245=0;
6117 		_loop245:
6118 		do {
6119 			if (((_tokenSet_36.member(LA(1))) && (_tokenSet_59.member(LA(2))))&&(LA(1)!=LITERAL_default)) {
6120 				statement();
6121 				astFactory.addASTChild(currentAST, returnAST);
6122 			}
6123 			else {
6124 				if ( _cnt245>=1 ) { break _loop245; } else {throw new NoViableAltException(LT(1), getFilename());}
6125 			}
6126 			
6127 			_cnt245++;
6128 		} while (true);
6129 		}
6130 		if ( inputState.guessing==0 ) {
6131 			caseSList_AST = (AST)currentAST.root;
6132 			caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SLIST,"SLIST")).add(caseSList_AST));
6133 			currentAST.root = caseSList_AST;
6134 			currentAST.child = caseSList_AST!=null &&caseSList_AST.getFirstChild()!=null ?
6135 				caseSList_AST.getFirstChild() : caseSList_AST;
6136 			currentAST.advanceChildToEnd();
6137 		}
6138 		caseSList_AST = (AST)currentAST.root;
6139 		returnAST = caseSList_AST;
6140 	}
6141 	
6142 	public final void expressionList() throws RecognitionException, TokenStreamException {
6143 		
6144 		returnAST = null;
6145 		ASTPair currentAST = new ASTPair();
6146 		AST expressionList_AST = null;
6147 		
6148 		expression();
6149 		astFactory.addASTChild(currentAST, returnAST);
6150 		{
6151 		_loop273:
6152 		do {
6153 			if ((LA(1)==COMMA)) {
6154 				AST tmp167_AST = null;
6155 				tmp167_AST = astFactory.create(LT(1));
6156 				astFactory.addASTChild(currentAST, tmp167_AST);
6157 				match(COMMA);
6158 				expression();
6159 				astFactory.addASTChild(currentAST, returnAST);
6160 			}
6161 			else {
6162 				break _loop273;
6163 			}
6164 			
6165 		} while (true);
6166 		}
6167 		if ( inputState.guessing==0 ) {
6168 			expressionList_AST = (AST)currentAST.root;
6169 			expressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ELIST,"ELIST")).add(expressionList_AST));
6170 			currentAST.root = expressionList_AST;
6171 			currentAST.child = expressionList_AST!=null &&expressionList_AST.getFirstChild()!=null ?
6172 				expressionList_AST.getFirstChild() : expressionList_AST;
6173 			currentAST.advanceChildToEnd();
6174 		}
6175 		expressionList_AST = (AST)currentAST.root;
6176 		returnAST = expressionList_AST;
6177 	}
6178 	
6179 	public final void resourceSpecification() throws RecognitionException, TokenStreamException {
6180 		
6181 		returnAST = null;
6182 		ASTPair currentAST = new ASTPair();
6183 		AST resourceSpecification_AST = null;
6184 		
6185 		AST tmp168_AST = null;
6186 		tmp168_AST = astFactory.create(LT(1));
6187 		astFactory.addASTChild(currentAST, tmp168_AST);
6188 		match(LPAREN);
6189 		resources();
6190 		astFactory.addASTChild(currentAST, returnAST);
6191 		{
6192 		switch ( LA(1)) {
6193 		case SEMI:
6194 		{
6195 			AST tmp169_AST = null;
6196 			tmp169_AST = astFactory.create(LT(1));
6197 			astFactory.addASTChild(currentAST, tmp169_AST);
6198 			match(SEMI);
6199 			break;
6200 		}
6201 		case RPAREN:
6202 		{
6203 			break;
6204 		}
6205 		default:
6206 		{
6207 			throw new NoViableAltException(LT(1), getFilename());
6208 		}
6209 		}
6210 		}
6211 		AST tmp170_AST = null;
6212 		tmp170_AST = astFactory.create(LT(1));
6213 		astFactory.addASTChild(currentAST, tmp170_AST);
6214 		match(RPAREN);
6215 		if ( inputState.guessing==0 ) {
6216 			resourceSpecification_AST = (AST)currentAST.root;
6217 			resourceSpecification_AST =
6218 			(AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE_SPECIFICATION,"RESOURCE_SPECIFICATION")).add(resourceSpecification_AST));
6219 			currentAST.root = resourceSpecification_AST;
6220 			currentAST.child = resourceSpecification_AST!=null &&resourceSpecification_AST.getFirstChild()!=null ?
6221 				resourceSpecification_AST.getFirstChild() : resourceSpecification_AST;
6222 			currentAST.advanceChildToEnd();
6223 		}
6224 		resourceSpecification_AST = (AST)currentAST.root;
6225 		returnAST = resourceSpecification_AST;
6226 	}
6227 	
6228 	public final void handler() throws RecognitionException, TokenStreamException {
6229 		
6230 		returnAST = null;
6231 		ASTPair currentAST = new ASTPair();
6232 		AST handler_AST = null;
6233 		
6234 		AST tmp171_AST = null;
6235 		tmp171_AST = astFactory.create(LT(1));
6236 		astFactory.makeASTRoot(currentAST, tmp171_AST);
6237 		match(LITERAL_catch);
6238 		AST tmp172_AST = null;
6239 		tmp172_AST = astFactory.create(LT(1));
6240 		astFactory.addASTChild(currentAST, tmp172_AST);
6241 		match(LPAREN);
6242 		catchParameterDeclaration();
6243 		astFactory.addASTChild(currentAST, returnAST);
6244 		AST tmp173_AST = null;
6245 		tmp173_AST = astFactory.create(LT(1));
6246 		astFactory.addASTChild(currentAST, tmp173_AST);
6247 		match(RPAREN);
6248 		compoundStatement();
6249 		astFactory.addASTChild(currentAST, returnAST);
6250 		handler_AST = (AST)currentAST.root;
6251 		returnAST = handler_AST;
6252 	}
6253 	
6254 	public final void finallyHandler() throws RecognitionException, TokenStreamException {
6255 		
6256 		returnAST = null;
6257 		ASTPair currentAST = new ASTPair();
6258 		AST finallyHandler_AST = null;
6259 		
6260 		AST tmp174_AST = null;
6261 		tmp174_AST = astFactory.create(LT(1));
6262 		astFactory.makeASTRoot(currentAST, tmp174_AST);
6263 		match(LITERAL_finally);
6264 		compoundStatement();
6265 		astFactory.addASTChild(currentAST, returnAST);
6266 		finallyHandler_AST = (AST)currentAST.root;
6267 		returnAST = finallyHandler_AST;
6268 	}
6269 	
6270 	public final void resources() throws RecognitionException, TokenStreamException {
6271 		
6272 		returnAST = null;
6273 		ASTPair currentAST = new ASTPair();
6274 		AST resources_AST = null;
6275 		
6276 		resource();
6277 		astFactory.addASTChild(currentAST, returnAST);
6278 		{
6279 		_loop263:
6280 		do {
6281 			if ((LA(1)==SEMI) && (_tokenSet_51.member(LA(2)))) {
6282 				AST tmp175_AST = null;
6283 				tmp175_AST = astFactory.create(LT(1));
6284 				astFactory.addASTChild(currentAST, tmp175_AST);
6285 				match(SEMI);
6286 				resource();
6287 				astFactory.addASTChild(currentAST, returnAST);
6288 			}
6289 			else {
6290 				break _loop263;
6291 			}
6292 			
6293 		} while (true);
6294 		}
6295 		if ( inputState.guessing==0 ) {
6296 			resources_AST = (AST)currentAST.root;
6297 			resources_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCES,"RESOURCES")).add(resources_AST));
6298 			currentAST.root = resources_AST;
6299 			currentAST.child = resources_AST!=null &&resources_AST.getFirstChild()!=null ?
6300 				resources_AST.getFirstChild() : resources_AST;
6301 			currentAST.advanceChildToEnd();
6302 		}
6303 		resources_AST = (AST)currentAST.root;
6304 		returnAST = resources_AST;
6305 	}
6306 	
6307 	public final void resource() throws RecognitionException, TokenStreamException {
6308 		
6309 		returnAST = null;
6310 		ASTPair currentAST = new ASTPair();
6311 		AST resource_AST = null;
6312 		
6313 		if ((LA(1)==IDENT) && (LA(2)==SEMI||LA(2)==RPAREN)) {
6314 			AST tmp176_AST = null;
6315 			tmp176_AST = astFactory.create(LT(1));
6316 			astFactory.addASTChild(currentAST, tmp176_AST);
6317 			match(IDENT);
6318 			resource_AST = (AST)currentAST.root;
6319 		}
6320 		else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) {
6321 			modifiers();
6322 			astFactory.addASTChild(currentAST, returnAST);
6323 			typeSpec(true);
6324 			astFactory.addASTChild(currentAST, returnAST);
6325 			AST tmp177_AST = null;
6326 			tmp177_AST = astFactory.create(LT(1));
6327 			astFactory.addASTChild(currentAST, tmp177_AST);
6328 			match(IDENT);
6329 			resource_assign();
6330 			astFactory.addASTChild(currentAST, returnAST);
6331 			if ( inputState.guessing==0 ) {
6332 				resource_AST = (AST)currentAST.root;
6333 				resource_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE,"RESOURCE")).add(resource_AST));
6334 				currentAST.root = resource_AST;
6335 				currentAST.child = resource_AST!=null &&resource_AST.getFirstChild()!=null ?
6336 					resource_AST.getFirstChild() : resource_AST;
6337 				currentAST.advanceChildToEnd();
6338 			}
6339 			resource_AST = (AST)currentAST.root;
6340 		}
6341 		else {
6342 			throw new NoViableAltException(LT(1), getFilename());
6343 		}
6344 		
6345 		returnAST = resource_AST;
6346 	}
6347 	
6348 	public final void resource_assign() throws RecognitionException, TokenStreamException {
6349 		
6350 		returnAST = null;
6351 		ASTPair currentAST = new ASTPair();
6352 		AST resource_assign_AST = null;
6353 		
6354 		AST tmp178_AST = null;
6355 		tmp178_AST = astFactory.create(LT(1));
6356 		astFactory.makeASTRoot(currentAST, tmp178_AST);
6357 		match(ASSIGN);
6358 		expression();
6359 		astFactory.addASTChild(currentAST, returnAST);
6360 		resource_assign_AST = (AST)currentAST.root;
6361 		returnAST = resource_assign_AST;
6362 	}
6363 	
6364 	public final void lambdaExpression() throws RecognitionException, TokenStreamException {
6365 		
6366 		returnAST = null;
6367 		ASTPair currentAST = new ASTPair();
6368 		AST lambdaExpression_AST = null;
6369 		
6370 		lambdaParameters();
6371 		astFactory.addASTChild(currentAST, returnAST);
6372 		AST tmp179_AST = null;
6373 		tmp179_AST = astFactory.create(LT(1));
6374 		astFactory.makeASTRoot(currentAST, tmp179_AST);
6375 		match(LAMBDA);
6376 		lambdaBody();
6377 		astFactory.addASTChild(currentAST, returnAST);
6378 		lambdaExpression_AST = (AST)currentAST.root;
6379 		returnAST = lambdaExpression_AST;
6380 	}
6381 	
6382 	public final void assignmentExpression() throws RecognitionException, TokenStreamException {
6383 		
6384 		returnAST = null;
6385 		ASTPair currentAST = new ASTPair();
6386 		AST assignmentExpression_AST = null;
6387 		
6388 		conditionalExpression();
6389 		astFactory.addASTChild(currentAST, returnAST);
6390 		{
6391 		switch ( LA(1)) {
6392 		case ASSIGN:
6393 		case PLUS_ASSIGN:
6394 		case MINUS_ASSIGN:
6395 		case STAR_ASSIGN:
6396 		case DIV_ASSIGN:
6397 		case MOD_ASSIGN:
6398 		case SR_ASSIGN:
6399 		case BSR_ASSIGN:
6400 		case SL_ASSIGN:
6401 		case BAND_ASSIGN:
6402 		case BXOR_ASSIGN:
6403 		case BOR_ASSIGN:
6404 		{
6405 			{
6406 			switch ( LA(1)) {
6407 			case ASSIGN:
6408 			{
6409 				AST tmp180_AST = null;
6410 				tmp180_AST = astFactory.create(LT(1));
6411 				astFactory.makeASTRoot(currentAST, tmp180_AST);
6412 				match(ASSIGN);
6413 				break;
6414 			}
6415 			case PLUS_ASSIGN:
6416 			{
6417 				AST tmp181_AST = null;
6418 				tmp181_AST = astFactory.create(LT(1));
6419 				astFactory.makeASTRoot(currentAST, tmp181_AST);
6420 				match(PLUS_ASSIGN);
6421 				break;
6422 			}
6423 			case MINUS_ASSIGN:
6424 			{
6425 				AST tmp182_AST = null;
6426 				tmp182_AST = astFactory.create(LT(1));
6427 				astFactory.makeASTRoot(currentAST, tmp182_AST);
6428 				match(MINUS_ASSIGN);
6429 				break;
6430 			}
6431 			case STAR_ASSIGN:
6432 			{
6433 				AST tmp183_AST = null;
6434 				tmp183_AST = astFactory.create(LT(1));
6435 				astFactory.makeASTRoot(currentAST, tmp183_AST);
6436 				match(STAR_ASSIGN);
6437 				break;
6438 			}
6439 			case DIV_ASSIGN:
6440 			{
6441 				AST tmp184_AST = null;
6442 				tmp184_AST = astFactory.create(LT(1));
6443 				astFactory.makeASTRoot(currentAST, tmp184_AST);
6444 				match(DIV_ASSIGN);
6445 				break;
6446 			}
6447 			case MOD_ASSIGN:
6448 			{
6449 				AST tmp185_AST = null;
6450 				tmp185_AST = astFactory.create(LT(1));
6451 				astFactory.makeASTRoot(currentAST, tmp185_AST);
6452 				match(MOD_ASSIGN);
6453 				break;
6454 			}
6455 			case SR_ASSIGN:
6456 			{
6457 				AST tmp186_AST = null;
6458 				tmp186_AST = astFactory.create(LT(1));
6459 				astFactory.makeASTRoot(currentAST, tmp186_AST);
6460 				match(SR_ASSIGN);
6461 				break;
6462 			}
6463 			case BSR_ASSIGN:
6464 			{
6465 				AST tmp187_AST = null;
6466 				tmp187_AST = astFactory.create(LT(1));
6467 				astFactory.makeASTRoot(currentAST, tmp187_AST);
6468 				match(BSR_ASSIGN);
6469 				break;
6470 			}
6471 			case SL_ASSIGN:
6472 			{
6473 				AST tmp188_AST = null;
6474 				tmp188_AST = astFactory.create(LT(1));
6475 				astFactory.makeASTRoot(currentAST, tmp188_AST);
6476 				match(SL_ASSIGN);
6477 				break;
6478 			}
6479 			case BAND_ASSIGN:
6480 			{
6481 				AST tmp189_AST = null;
6482 				tmp189_AST = astFactory.create(LT(1));
6483 				astFactory.makeASTRoot(currentAST, tmp189_AST);
6484 				match(BAND_ASSIGN);
6485 				break;
6486 			}
6487 			case BXOR_ASSIGN:
6488 			{
6489 				AST tmp190_AST = null;
6490 				tmp190_AST = astFactory.create(LT(1));
6491 				astFactory.makeASTRoot(currentAST, tmp190_AST);
6492 				match(BXOR_ASSIGN);
6493 				break;
6494 			}
6495 			case BOR_ASSIGN:
6496 			{
6497 				AST tmp191_AST = null;
6498 				tmp191_AST = astFactory.create(LT(1));
6499 				astFactory.makeASTRoot(currentAST, tmp191_AST);
6500 				match(BOR_ASSIGN);
6501 				break;
6502 			}
6503 			default:
6504 			{
6505 				throw new NoViableAltException(LT(1), getFilename());
6506 			}
6507 			}
6508 			}
6509 			{
6510 			boolean synPredMatched279 = false;
6511 			if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) {
6512 				int _m279 = mark();
6513 				synPredMatched279 = true;
6514 				inputState.guessing++;
6515 				try {
6516 					{
6517 					lambdaExpression();
6518 					}
6519 				}
6520 				catch (RecognitionException pe) {
6521 					synPredMatched279 = false;
6522 				}
6523 				rewind(_m279);
6524 inputState.guessing--;
6525 			}
6526 			if ( synPredMatched279 ) {
6527 				lambdaExpression();
6528 				astFactory.addASTChild(currentAST, returnAST);
6529 			}
6530 			else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {
6531 				assignmentExpression();
6532 				astFactory.addASTChild(currentAST, returnAST);
6533 			}
6534 			else {
6535 				throw new NoViableAltException(LT(1), getFilename());
6536 			}
6537 			
6538 			}
6539 			break;
6540 		}
6541 		case FINAL:
6542 		case ABSTRACT:
6543 		case STRICTFP:
6544 		case SEMI:
6545 		case RBRACK:
6546 		case LITERAL_void:
6547 		case LITERAL_boolean:
6548 		case LITERAL_byte:
6549 		case LITERAL_char:
6550 		case LITERAL_short:
6551 		case LITERAL_int:
6552 		case LITERAL_float:
6553 		case LITERAL_long:
6554 		case LITERAL_double:
6555 		case IDENT:
6556 		case STAR:
6557 		case LITERAL_private:
6558 		case LITERAL_public:
6559 		case LITERAL_protected:
6560 		case LITERAL_static:
6561 		case LITERAL_transient:
6562 		case LITERAL_native:
6563 		case LITERAL_synchronized:
6564 		case LITERAL_volatile:
6565 		case LITERAL_class:
6566 		case LITERAL_interface:
6567 		case LCURLY:
6568 		case RCURLY:
6569 		case COMMA:
6570 		case LPAREN:
6571 		case RPAREN:
6572 		case LITERAL_this:
6573 		case LITERAL_super:
6574 		case COLON:
6575 		case LITERAL_if:
6576 		case LITERAL_while:
6577 		case LITERAL_do:
6578 		case LITERAL_break:
6579 		case LITERAL_continue:
6580 		case LITERAL_return:
6581 		case LITERAL_switch:
6582 		case LITERAL_throw:
6583 		case LITERAL_for:
6584 		case LITERAL_else:
6585 		case LITERAL_case:
6586 		case LITERAL_default:
6587 		case LITERAL_try:
6588 		case LT:
6589 		case GT:
6590 		case LE:
6591 		case GE:
6592 		case LITERAL_instanceof:
6593 		case SL:
6594 		case SR:
6595 		case BSR:
6596 		case PLUS:
6597 		case MINUS:
6598 		case DIV:
6599 		case MOD:
6600 		case INC:
6601 		case DEC:
6602 		case BNOT:
6603 		case LNOT:
6604 		case LITERAL_true:
6605 		case LITERAL_false:
6606 		case LITERAL_null:
6607 		case LITERAL_new:
6608 		case NUM_INT:
6609 		case CHAR_LITERAL:
6610 		case STRING_LITERAL:
6611 		case NUM_FLOAT:
6612 		case NUM_LONG:
6613 		case NUM_DOUBLE:
6614 		case ASSERT:
6615 		case ENUM:
6616 		case AT:
6617 		{
6618 			break;
6619 		}
6620 		default:
6621 		{
6622 			throw new NoViableAltException(LT(1), getFilename());
6623 		}
6624 		}
6625 		}
6626 		assignmentExpression_AST = (AST)currentAST.root;
6627 		returnAST = assignmentExpression_AST;
6628 	}
6629 	
6630 	public final void logicalOrExpression() throws RecognitionException, TokenStreamException {
6631 		
6632 		returnAST = null;
6633 		ASTPair currentAST = new ASTPair();
6634 		AST logicalOrExpression_AST = null;
6635 		
6636 		logicalAndExpression();
6637 		astFactory.addASTChild(currentAST, returnAST);
6638 		{
6639 		_loop290:
6640 		do {
6641 			if ((LA(1)==LOR)) {
6642 				AST tmp192_AST = null;
6643 				tmp192_AST = astFactory.create(LT(1));
6644 				astFactory.makeASTRoot(currentAST, tmp192_AST);
6645 				match(LOR);
6646 				logicalAndExpression();
6647 				astFactory.addASTChild(currentAST, returnAST);
6648 			}
6649 			else {
6650 				break _loop290;
6651 			}
6652 			
6653 		} while (true);
6654 		}
6655 		logicalOrExpression_AST = (AST)currentAST.root;
6656 		returnAST = logicalOrExpression_AST;
6657 	}
6658 	
6659 	public final void logicalAndExpression() throws RecognitionException, TokenStreamException {
6660 		
6661 		returnAST = null;
6662 		ASTPair currentAST = new ASTPair();
6663 		AST logicalAndExpression_AST = null;
6664 		
6665 		inclusiveOrExpression();
6666 		astFactory.addASTChild(currentAST, returnAST);
6667 		{
6668 		_loop293:
6669 		do {
6670 			if ((LA(1)==LAND)) {
6671 				AST tmp193_AST = null;
6672 				tmp193_AST = astFactory.create(LT(1));
6673 				astFactory.makeASTRoot(currentAST, tmp193_AST);
6674 				match(LAND);
6675 				inclusiveOrExpression();
6676 				astFactory.addASTChild(currentAST, returnAST);
6677 			}
6678 			else {
6679 				break _loop293;
6680 			}
6681 			
6682 		} while (true);
6683 		}
6684 		logicalAndExpression_AST = (AST)currentAST.root;
6685 		returnAST = logicalAndExpression_AST;
6686 	}
6687 	
6688 	public final void inclusiveOrExpression() throws RecognitionException, TokenStreamException {
6689 		
6690 		returnAST = null;
6691 		ASTPair currentAST = new ASTPair();
6692 		AST inclusiveOrExpression_AST = null;
6693 		
6694 		exclusiveOrExpression();
6695 		astFactory.addASTChild(currentAST, returnAST);
6696 		{
6697 		_loop296:
6698 		do {
6699 			if ((LA(1)==BOR)) {
6700 				AST tmp194_AST = null;
6701 				tmp194_AST = astFactory.create(LT(1));
6702 				astFactory.makeASTRoot(currentAST, tmp194_AST);
6703 				match(BOR);
6704 				exclusiveOrExpression();
6705 				astFactory.addASTChild(currentAST, returnAST);
6706 			}
6707 			else {
6708 				break _loop296;
6709 			}
6710 			
6711 		} while (true);
6712 		}
6713 		inclusiveOrExpression_AST = (AST)currentAST.root;
6714 		returnAST = inclusiveOrExpression_AST;
6715 	}
6716 	
6717 	public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException {
6718 		
6719 		returnAST = null;
6720 		ASTPair currentAST = new ASTPair();
6721 		AST exclusiveOrExpression_AST = null;
6722 		
6723 		andExpression();
6724 		astFactory.addASTChild(currentAST, returnAST);
6725 		{
6726 		_loop299:
6727 		do {
6728 			if ((LA(1)==BXOR)) {
6729 				AST tmp195_AST = null;
6730 				tmp195_AST = astFactory.create(LT(1));
6731 				astFactory.makeASTRoot(currentAST, tmp195_AST);
6732 				match(BXOR);
6733 				andExpression();
6734 				astFactory.addASTChild(currentAST, returnAST);
6735 			}
6736 			else {
6737 				break _loop299;
6738 			}
6739 			
6740 		} while (true);
6741 		}
6742 		exclusiveOrExpression_AST = (AST)currentAST.root;
6743 		returnAST = exclusiveOrExpression_AST;
6744 	}
6745 	
6746 	public final void andExpression() throws RecognitionException, TokenStreamException {
6747 		
6748 		returnAST = null;
6749 		ASTPair currentAST = new ASTPair();
6750 		AST andExpression_AST = null;
6751 		
6752 		equalityExpression();
6753 		astFactory.addASTChild(currentAST, returnAST);
6754 		{
6755 		_loop302:
6756 		do {
6757 			if ((LA(1)==BAND)) {
6758 				AST tmp196_AST = null;
6759 				tmp196_AST = astFactory.create(LT(1));
6760 				astFactory.makeASTRoot(currentAST, tmp196_AST);
6761 				match(BAND);
6762 				equalityExpression();
6763 				astFactory.addASTChild(currentAST, returnAST);
6764 			}
6765 			else {
6766 				break _loop302;
6767 			}
6768 			
6769 		} while (true);
6770 		}
6771 		andExpression_AST = (AST)currentAST.root;
6772 		returnAST = andExpression_AST;
6773 	}
6774 	
6775 	public final void equalityExpression() throws RecognitionException, TokenStreamException {
6776 		
6777 		returnAST = null;
6778 		ASTPair currentAST = new ASTPair();
6779 		AST equalityExpression_AST = null;
6780 		
6781 		relationalExpression();
6782 		astFactory.addASTChild(currentAST, returnAST);
6783 		{
6784 		_loop306:
6785 		do {
6786 			if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) {
6787 				{
6788 				switch ( LA(1)) {
6789 				case NOT_EQUAL:
6790 				{
6791 					AST tmp197_AST = null;
6792 					tmp197_AST = astFactory.create(LT(1));
6793 					astFactory.makeASTRoot(currentAST, tmp197_AST);
6794 					match(NOT_EQUAL);
6795 					break;
6796 				}
6797 				case EQUAL:
6798 				{
6799 					AST tmp198_AST = null;
6800 					tmp198_AST = astFactory.create(LT(1));
6801 					astFactory.makeASTRoot(currentAST, tmp198_AST);
6802 					match(EQUAL);
6803 					break;
6804 				}
6805 				default:
6806 				{
6807 					throw new NoViableAltException(LT(1), getFilename());
6808 				}
6809 				}
6810 				}
6811 				relationalExpression();
6812 				astFactory.addASTChild(currentAST, returnAST);
6813 			}
6814 			else {
6815 				break _loop306;
6816 			}
6817 			
6818 		} while (true);
6819 		}
6820 		equalityExpression_AST = (AST)currentAST.root;
6821 		returnAST = equalityExpression_AST;
6822 	}
6823 	
6824 	public final void relationalExpression() throws RecognitionException, TokenStreamException {
6825 		
6826 		returnAST = null;
6827 		ASTPair currentAST = new ASTPair();
6828 		AST relationalExpression_AST = null;
6829 		
6830 		shiftExpression();
6831 		astFactory.addASTChild(currentAST, returnAST);
6832 		{
6833 		if ((LA(1)==LITERAL_instanceof) && (_tokenSet_9.member(LA(2)))) {
6834 			AST tmp199_AST = null;
6835 			tmp199_AST = astFactory.create(LT(1));
6836 			astFactory.makeASTRoot(currentAST, tmp199_AST);
6837 			match(LITERAL_instanceof);
6838 			typeSpec(true);
6839 			astFactory.addASTChild(currentAST, returnAST);
6840 		}
6841 		else if ((_tokenSet_62.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
6842 		}
6843 		else {
6844 			throw new NoViableAltException(LT(1), getFilename());
6845 		}
6846 		
6847 		}
6848 		{
6849 		{
6850 		_loop312:
6851 		do {
6852 			if (((LA(1) >= LT && LA(1) <= GE)) && (_tokenSet_12.member(LA(2)))) {
6853 				{
6854 				switch ( LA(1)) {
6855 				case LT:
6856 				{
6857 					AST tmp200_AST = null;
6858 					tmp200_AST = astFactory.create(LT(1));
6859 					astFactory.makeASTRoot(currentAST, tmp200_AST);
6860 					match(LT);
6861 					break;
6862 				}
6863 				case GT:
6864 				{
6865 					AST tmp201_AST = null;
6866 					tmp201_AST = astFactory.create(LT(1));
6867 					astFactory.makeASTRoot(currentAST, tmp201_AST);
6868 					match(GT);
6869 					break;
6870 				}
6871 				case LE:
6872 				{
6873 					AST tmp202_AST = null;
6874 					tmp202_AST = astFactory.create(LT(1));
6875 					astFactory.makeASTRoot(currentAST, tmp202_AST);
6876 					match(LE);
6877 					break;
6878 				}
6879 				case GE:
6880 				{
6881 					AST tmp203_AST = null;
6882 					tmp203_AST = astFactory.create(LT(1));
6883 					astFactory.makeASTRoot(currentAST, tmp203_AST);
6884 					match(GE);
6885 					break;
6886 				}
6887 				default:
6888 				{
6889 					throw new NoViableAltException(LT(1), getFilename());
6890 				}
6891 				}
6892 				}
6893 				shiftExpression();
6894 				astFactory.addASTChild(currentAST, returnAST);
6895 			}
6896 			else {
6897 				break _loop312;
6898 			}
6899 			
6900 		} while (true);
6901 		}
6902 		}
6903 		relationalExpression_AST = (AST)currentAST.root;
6904 		returnAST = relationalExpression_AST;
6905 	}
6906 	
6907 	public final void shiftExpression() throws RecognitionException, TokenStreamException {
6908 		
6909 		returnAST = null;
6910 		ASTPair currentAST = new ASTPair();
6911 		AST shiftExpression_AST = null;
6912 		
6913 		additiveExpression();
6914 		astFactory.addASTChild(currentAST, returnAST);
6915 		{
6916 		_loop316:
6917 		do {
6918 			if (((LA(1) >= SL && LA(1) <= BSR)) && (_tokenSet_12.member(LA(2)))) {
6919 				{
6920 				switch ( LA(1)) {
6921 				case SL:
6922 				{
6923 					AST tmp204_AST = null;
6924 					tmp204_AST = astFactory.create(LT(1));
6925 					astFactory.makeASTRoot(currentAST, tmp204_AST);
6926 					match(SL);
6927 					break;
6928 				}
6929 				case SR:
6930 				{
6931 					AST tmp205_AST = null;
6932 					tmp205_AST = astFactory.create(LT(1));
6933 					astFactory.makeASTRoot(currentAST, tmp205_AST);
6934 					match(SR);
6935 					break;
6936 				}
6937 				case BSR:
6938 				{
6939 					AST tmp206_AST = null;
6940 					tmp206_AST = astFactory.create(LT(1));
6941 					astFactory.makeASTRoot(currentAST, tmp206_AST);
6942 					match(BSR);
6943 					break;
6944 				}
6945 				default:
6946 				{
6947 					throw new NoViableAltException(LT(1), getFilename());
6948 				}
6949 				}
6950 				}
6951 				additiveExpression();
6952 				astFactory.addASTChild(currentAST, returnAST);
6953 			}
6954 			else {
6955 				break _loop316;
6956 			}
6957 			
6958 		} while (true);
6959 		}
6960 		shiftExpression_AST = (AST)currentAST.root;
6961 		returnAST = shiftExpression_AST;
6962 	}
6963 	
6964 	public final void additiveExpression() throws RecognitionException, TokenStreamException {
6965 		
6966 		returnAST = null;
6967 		ASTPair currentAST = new ASTPair();
6968 		AST additiveExpression_AST = null;
6969 		
6970 		multiplicativeExpression();
6971 		astFactory.addASTChild(currentAST, returnAST);
6972 		{
6973 		_loop320:
6974 		do {
6975 			if ((LA(1)==PLUS||LA(1)==MINUS) && (_tokenSet_12.member(LA(2)))) {
6976 				{
6977 				switch ( LA(1)) {
6978 				case PLUS:
6979 				{
6980 					AST tmp207_AST = null;
6981 					tmp207_AST = astFactory.create(LT(1));
6982 					astFactory.makeASTRoot(currentAST, tmp207_AST);
6983 					match(PLUS);
6984 					break;
6985 				}
6986 				case MINUS:
6987 				{
6988 					AST tmp208_AST = null;
6989 					tmp208_AST = astFactory.create(LT(1));
6990 					astFactory.makeASTRoot(currentAST, tmp208_AST);
6991 					match(MINUS);
6992 					break;
6993 				}
6994 				default:
6995 				{
6996 					throw new NoViableAltException(LT(1), getFilename());
6997 				}
6998 				}
6999 				}
7000 				multiplicativeExpression();
7001 				astFactory.addASTChild(currentAST, returnAST);
7002 			}
7003 			else {
7004 				break _loop320;
7005 			}
7006 			
7007 		} while (true);
7008 		}
7009 		additiveExpression_AST = (AST)currentAST.root;
7010 		returnAST = additiveExpression_AST;
7011 	}
7012 	
7013 	public final void multiplicativeExpression() throws RecognitionException, TokenStreamException {
7014 		
7015 		returnAST = null;
7016 		ASTPair currentAST = new ASTPair();
7017 		AST multiplicativeExpression_AST = null;
7018 		
7019 		unaryExpression();
7020 		astFactory.addASTChild(currentAST, returnAST);
7021 		{
7022 		_loop324:
7023 		do {
7024 			if ((_tokenSet_63.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
7025 				{
7026 				switch ( LA(1)) {
7027 				case STAR:
7028 				{
7029 					AST tmp209_AST = null;
7030 					tmp209_AST = astFactory.create(LT(1));
7031 					astFactory.makeASTRoot(currentAST, tmp209_AST);
7032 					match(STAR);
7033 					break;
7034 				}
7035 				case DIV:
7036 				{
7037 					AST tmp210_AST = null;
7038 					tmp210_AST = astFactory.create(LT(1));
7039 					astFactory.makeASTRoot(currentAST, tmp210_AST);
7040 					match(DIV);
7041 					break;
7042 				}
7043 				case MOD:
7044 				{
7045 					AST tmp211_AST = null;
7046 					tmp211_AST = astFactory.create(LT(1));
7047 					astFactory.makeASTRoot(currentAST, tmp211_AST);
7048 					match(MOD);
7049 					break;
7050 				}
7051 				default:
7052 				{
7053 					throw new NoViableAltException(LT(1), getFilename());
7054 				}
7055 				}
7056 				}
7057 				unaryExpression();
7058 				astFactory.addASTChild(currentAST, returnAST);
7059 			}
7060 			else {
7061 				break _loop324;
7062 			}
7063 			
7064 		} while (true);
7065 		}
7066 		multiplicativeExpression_AST = (AST)currentAST.root;
7067 		returnAST = multiplicativeExpression_AST;
7068 	}
7069 	
7070 	public final void unaryExpression() throws RecognitionException, TokenStreamException {
7071 		
7072 		returnAST = null;
7073 		ASTPair currentAST = new ASTPair();
7074 		AST unaryExpression_AST = null;
7075 		
7076 		switch ( LA(1)) {
7077 		case INC:
7078 		{
7079 			AST tmp212_AST = null;
7080 			tmp212_AST = astFactory.create(LT(1));
7081 			astFactory.makeASTRoot(currentAST, tmp212_AST);
7082 			match(INC);
7083 			unaryExpression();
7084 			astFactory.addASTChild(currentAST, returnAST);
7085 			unaryExpression_AST = (AST)currentAST.root;
7086 			break;
7087 		}
7088 		case DEC:
7089 		{
7090 			AST tmp213_AST = null;
7091 			tmp213_AST = astFactory.create(LT(1));
7092 			astFactory.makeASTRoot(currentAST, tmp213_AST);
7093 			match(DEC);
7094 			unaryExpression();
7095 			astFactory.addASTChild(currentAST, returnAST);
7096 			unaryExpression_AST = (AST)currentAST.root;
7097 			break;
7098 		}
7099 		case MINUS:
7100 		{
7101 			AST tmp214_AST = null;
7102 			tmp214_AST = astFactory.create(LT(1));
7103 			astFactory.makeASTRoot(currentAST, tmp214_AST);
7104 			match(MINUS);
7105 			if ( inputState.guessing==0 ) {
7106 				tmp214_AST.setType(UNARY_MINUS);
7107 			}
7108 			unaryExpression();
7109 			astFactory.addASTChild(currentAST, returnAST);
7110 			unaryExpression_AST = (AST)currentAST.root;
7111 			break;
7112 		}
7113 		case PLUS:
7114 		{
7115 			AST tmp215_AST = null;
7116 			tmp215_AST = astFactory.create(LT(1));
7117 			astFactory.makeASTRoot(currentAST, tmp215_AST);
7118 			match(PLUS);
7119 			if ( inputState.guessing==0 ) {
7120 				tmp215_AST.setType(UNARY_PLUS);
7121 			}
7122 			unaryExpression();
7123 			astFactory.addASTChild(currentAST, returnAST);
7124 			unaryExpression_AST = (AST)currentAST.root;
7125 			break;
7126 		}
7127 		case LITERAL_void:
7128 		case LITERAL_boolean:
7129 		case LITERAL_byte:
7130 		case LITERAL_char:
7131 		case LITERAL_short:
7132 		case LITERAL_int:
7133 		case LITERAL_float:
7134 		case LITERAL_long:
7135 		case LITERAL_double:
7136 		case IDENT:
7137 		case LPAREN:
7138 		case LITERAL_this:
7139 		case LITERAL_super:
7140 		case BNOT:
7141 		case LNOT:
7142 		case LITERAL_true:
7143 		case LITERAL_false:
7144 		case LITERAL_null:
7145 		case LITERAL_new:
7146 		case NUM_INT:
7147 		case CHAR_LITERAL:
7148 		case STRING_LITERAL:
7149 		case NUM_FLOAT:
7150 		case NUM_LONG:
7151 		case NUM_DOUBLE:
7152 		case AT:
7153 		{
7154 			unaryExpressionNotPlusMinus();
7155 			astFactory.addASTChild(currentAST, returnAST);
7156 			unaryExpression_AST = (AST)currentAST.root;
7157 			break;
7158 		}
7159 		default:
7160 		{
7161 			throw new NoViableAltException(LT(1), getFilename());
7162 		}
7163 		}
7164 		returnAST = unaryExpression_AST;
7165 	}
7166 	
7167 	public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException {
7168 		
7169 		returnAST = null;
7170 		ASTPair currentAST = new ASTPair();
7171 		AST unaryExpressionNotPlusMinus_AST = null;
7172 		Token  lpb = null;
7173 		AST lpb_AST = null;
7174 		Token  lp = null;
7175 		AST lp_AST = null;
7176 		Token  lpl = null;
7177 		AST lpl_AST = null;
7178 		
7179 		switch ( LA(1)) {
7180 		case BNOT:
7181 		{
7182 			AST tmp216_AST = null;
7183 			tmp216_AST = astFactory.create(LT(1));
7184 			astFactory.makeASTRoot(currentAST, tmp216_AST);
7185 			match(BNOT);
7186 			unaryExpression();
7187 			astFactory.addASTChild(currentAST, returnAST);
7188 			unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
7189 			break;
7190 		}
7191 		case LNOT:
7192 		{
7193 			AST tmp217_AST = null;
7194 			tmp217_AST = astFactory.create(LT(1));
7195 			astFactory.makeASTRoot(currentAST, tmp217_AST);
7196 			match(LNOT);
7197 			unaryExpression();
7198 			astFactory.addASTChild(currentAST, returnAST);
7199 			unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
7200 			break;
7201 		}
7202 		case LITERAL_void:
7203 		case LITERAL_boolean:
7204 		case LITERAL_byte:
7205 		case LITERAL_char:
7206 		case LITERAL_short:
7207 		case LITERAL_int:
7208 		case LITERAL_float:
7209 		case LITERAL_long:
7210 		case LITERAL_double:
7211 		case IDENT:
7212 		case LPAREN:
7213 		case LITERAL_this:
7214 		case LITERAL_super:
7215 		case LITERAL_true:
7216 		case LITERAL_false:
7217 		case LITERAL_null:
7218 		case LITERAL_new:
7219 		case NUM_INT:
7220 		case CHAR_LITERAL:
7221 		case STRING_LITERAL:
7222 		case NUM_FLOAT:
7223 		case NUM_LONG:
7224 		case NUM_DOUBLE:
7225 		case AT:
7226 		{
7227 			{
7228 			boolean synPredMatched329 = false;
7229 			if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) {
7230 				int _m329 = mark();
7231 				synPredMatched329 = true;
7232 				inputState.guessing++;
7233 				try {
7234 					{
7235 					match(LPAREN);
7236 					builtInTypeSpec(true);
7237 					match(RPAREN);
7238 					unaryExpression();
7239 					}
7240 				}
7241 				catch (RecognitionException pe) {
7242 					synPredMatched329 = false;
7243 				}
7244 				rewind(_m329);
7245 inputState.guessing--;
7246 			}
7247 			if ( synPredMatched329 ) {
7248 				lpb = LT(1);
7249 				lpb_AST = astFactory.create(lpb);
7250 				astFactory.makeASTRoot(currentAST, lpb_AST);
7251 				match(LPAREN);
7252 				if ( inputState.guessing==0 ) {
7253 					lpb_AST.setType(TYPECAST);
7254 				}
7255 				builtInTypeSpec(true);
7256 				astFactory.addASTChild(currentAST, returnAST);
7257 				AST tmp218_AST = null;
7258 				tmp218_AST = astFactory.create(LT(1));
7259 				astFactory.addASTChild(currentAST, tmp218_AST);
7260 				match(RPAREN);
7261 				unaryExpression();
7262 				astFactory.addASTChild(currentAST, returnAST);
7263 			}
7264 			else {
7265 				boolean synPredMatched331 = false;
7266 				if (((LA(1)==LPAREN) && (LA(2)==IDENT||LA(2)==AT))) {
7267 					int _m331 = mark();
7268 					synPredMatched331 = true;
7269 					inputState.guessing++;
7270 					try {
7271 						{
7272 						match(LPAREN);
7273 						typeCastParameters();
7274 						match(RPAREN);
7275 						unaryExpressionNotPlusMinus();
7276 						}
7277 					}
7278 					catch (RecognitionException pe) {
7279 						synPredMatched331 = false;
7280 					}
7281 					rewind(_m331);
7282 inputState.guessing--;
7283 				}
7284 				if ( synPredMatched331 ) {
7285 					lp = LT(1);
7286 					lp_AST = astFactory.create(lp);
7287 					astFactory.makeASTRoot(currentAST, lp_AST);
7288 					match(LPAREN);
7289 					if ( inputState.guessing==0 ) {
7290 						lp_AST.setType(TYPECAST);
7291 					}
7292 					typeCastParameters();
7293 					astFactory.addASTChild(currentAST, returnAST);
7294 					AST tmp219_AST = null;
7295 					tmp219_AST = astFactory.create(LT(1));
7296 					astFactory.addASTChild(currentAST, tmp219_AST);
7297 					match(RPAREN);
7298 					unaryExpressionNotPlusMinus();
7299 					astFactory.addASTChild(currentAST, returnAST);
7300 				}
7301 				else {
7302 					boolean synPredMatched333 = false;
7303 					if (((LA(1)==LPAREN) && (LA(2)==IDENT||LA(2)==AT))) {
7304 						int _m333 = mark();
7305 						synPredMatched333 = true;
7306 						inputState.guessing++;
7307 						try {
7308 							{
7309 							match(LPAREN);
7310 							typeCastParameters();
7311 							match(RPAREN);
7312 							lambdaExpression();
7313 							}
7314 						}
7315 						catch (RecognitionException pe) {
7316 							synPredMatched333 = false;
7317 						}
7318 						rewind(_m333);
7319 inputState.guessing--;
7320 					}
7321 					if ( synPredMatched333 ) {
7322 						lpl = LT(1);
7323 						lpl_AST = astFactory.create(lpl);
7324 						astFactory.makeASTRoot(currentAST, lpl_AST);
7325 						match(LPAREN);
7326 						if ( inputState.guessing==0 ) {
7327 							lpl_AST.setType(TYPECAST);
7328 						}
7329 						typeCastParameters();
7330 						astFactory.addASTChild(currentAST, returnAST);
7331 						AST tmp220_AST = null;
7332 						tmp220_AST = astFactory.create(LT(1));
7333 						astFactory.addASTChild(currentAST, tmp220_AST);
7334 						match(RPAREN);
7335 						lambdaExpression();
7336 						astFactory.addASTChild(currentAST, returnAST);
7337 					}
7338 					else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_17.member(LA(2)))) {
7339 						postfixExpression();
7340 						astFactory.addASTChild(currentAST, returnAST);
7341 					}
7342 					else {
7343 						throw new NoViableAltException(LT(1), getFilename());
7344 					}
7345 					}}
7346 					}
7347 					unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
7348 					break;
7349 				}
7350 				default:
7351 				{
7352 					throw new NoViableAltException(LT(1), getFilename());
7353 				}
7354 				}
7355 				returnAST = unaryExpressionNotPlusMinus_AST;
7356 			}
7357 			
7358 	public final void typeCastParameters() throws RecognitionException, TokenStreamException {
7359 		
7360 		returnAST = null;
7361 		ASTPair currentAST = new ASTPair();
7362 		AST typeCastParameters_AST = null;
7363 		
7364 		classTypeSpec(true);
7365 		astFactory.addASTChild(currentAST, returnAST);
7366 		{
7367 		_loop336:
7368 		do {
7369 			if ((LA(1)==BAND)) {
7370 				AST tmp221_AST = null;
7371 				tmp221_AST = astFactory.create(LT(1));
7372 				astFactory.makeASTRoot(currentAST, tmp221_AST);
7373 				match(BAND);
7374 				classTypeSpec(true);
7375 				astFactory.addASTChild(currentAST, returnAST);
7376 			}
7377 			else {
7378 				break _loop336;
7379 			}
7380 			
7381 		} while (true);
7382 		}
7383 		typeCastParameters_AST = (AST)currentAST.root;
7384 		returnAST = typeCastParameters_AST;
7385 	}
7386 	
7387 	public final void postfixExpression() throws RecognitionException, TokenStreamException {
7388 		
7389 		returnAST = null;
7390 		ASTPair currentAST = new ASTPair();
7391 		AST postfixExpression_AST = null;
7392 		Token  dc = null;
7393 		AST dc_AST = null;
7394 		Token  lbc = null;
7395 		AST lbc_AST = null;
7396 		Token  lb = null;
7397 		AST lb_AST = null;
7398 		Token  lp = null;
7399 		AST lp_AST = null;
7400 		Token  in = null;
7401 		AST in_AST = null;
7402 		Token  de = null;
7403 		AST de_AST = null;
7404 		
7405 		primaryExpression();
7406 		astFactory.addASTChild(currentAST, returnAST);
7407 		{
7408 		_loop348:
7409 		do {
7410 			switch ( LA(1)) {
7411 			case DOT:
7412 			{
7413 				AST tmp222_AST = null;
7414 				tmp222_AST = astFactory.create(LT(1));
7415 				astFactory.makeASTRoot(currentAST, tmp222_AST);
7416 				match(DOT);
7417 				{
7418 				switch ( LA(1)) {
7419 				case IDENT:
7420 				case LITERAL_this:
7421 				case LITERAL_super:
7422 				case LT:
7423 				{
7424 					{
7425 					switch ( LA(1)) {
7426 					case LT:
7427 					{
7428 						typeArguments(false);
7429 						astFactory.addASTChild(currentAST, returnAST);
7430 						break;
7431 					}
7432 					case IDENT:
7433 					case LITERAL_this:
7434 					case LITERAL_super:
7435 					{
7436 						break;
7437 					}
7438 					default:
7439 					{
7440 						throw new NoViableAltException(LT(1), getFilename());
7441 					}
7442 					}
7443 					}
7444 					{
7445 					switch ( LA(1)) {
7446 					case IDENT:
7447 					{
7448 						AST tmp223_AST = null;
7449 						tmp223_AST = astFactory.create(LT(1));
7450 						astFactory.addASTChild(currentAST, tmp223_AST);
7451 						match(IDENT);
7452 						break;
7453 					}
7454 					case LITERAL_this:
7455 					{
7456 						AST tmp224_AST = null;
7457 						tmp224_AST = astFactory.create(LT(1));
7458 						astFactory.addASTChild(currentAST, tmp224_AST);
7459 						match(LITERAL_this);
7460 						break;
7461 					}
7462 					case LITERAL_super:
7463 					{
7464 						AST tmp225_AST = null;
7465 						tmp225_AST = astFactory.create(LT(1));
7466 						astFactory.addASTChild(currentAST, tmp225_AST);
7467 						match(LITERAL_super);
7468 						break;
7469 					}
7470 					default:
7471 					{
7472 						throw new NoViableAltException(LT(1), getFilename());
7473 					}
7474 					}
7475 					}
7476 					break;
7477 				}
7478 				case LITERAL_class:
7479 				{
7480 					AST tmp226_AST = null;
7481 					tmp226_AST = astFactory.create(LT(1));
7482 					astFactory.addASTChild(currentAST, tmp226_AST);
7483 					match(LITERAL_class);
7484 					break;
7485 				}
7486 				case LITERAL_new:
7487 				{
7488 					newExpression();
7489 					astFactory.addASTChild(currentAST, returnAST);
7490 					break;
7491 				}
7492 				default:
7493 				{
7494 					throw new NoViableAltException(LT(1), getFilename());
7495 				}
7496 				}
7497 				}
7498 				break;
7499 			}
7500 			case DOUBLE_COLON:
7501 			{
7502 				dc = LT(1);
7503 				dc_AST = astFactory.create(dc);
7504 				astFactory.makeASTRoot(currentAST, dc_AST);
7505 				match(DOUBLE_COLON);
7506 				if ( inputState.guessing==0 ) {
7507 					dc_AST.setType(METHOD_REF);
7508 				}
7509 				{
7510 				{
7511 				switch ( LA(1)) {
7512 				case LT:
7513 				{
7514 					typeArguments(false);
7515 					astFactory.addASTChild(currentAST, returnAST);
7516 					break;
7517 				}
7518 				case IDENT:
7519 				case LITERAL_new:
7520 				{
7521 					break;
7522 				}
7523 				default:
7524 				{
7525 					throw new NoViableAltException(LT(1), getFilename());
7526 				}
7527 				}
7528 				}
7529 				{
7530 				switch ( LA(1)) {
7531 				case IDENT:
7532 				{
7533 					AST tmp227_AST = null;
7534 					tmp227_AST = astFactory.create(LT(1));
7535 					astFactory.addASTChild(currentAST, tmp227_AST);
7536 					match(IDENT);
7537 					break;
7538 				}
7539 				case LITERAL_new:
7540 				{
7541 					AST tmp228_AST = null;
7542 					tmp228_AST = astFactory.create(LT(1));
7543 					astFactory.addASTChild(currentAST, tmp228_AST);
7544 					match(LITERAL_new);
7545 					break;
7546 				}
7547 				default:
7548 				{
7549 					throw new NoViableAltException(LT(1), getFilename());
7550 				}
7551 				}
7552 				}
7553 				}
7554 				break;
7555 			}
7556 			default:
7557 				if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
7558 					{
7559 					int _cnt346=0;
7560 					_loop346:
7561 					do {
7562 						if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
7563 							lbc = LT(1);
7564 							lbc_AST = astFactory.create(lbc);
7565 							astFactory.makeASTRoot(currentAST, lbc_AST);
7566 							match(LBRACK);
7567 							if ( inputState.guessing==0 ) {
7568 								lbc_AST.setType(ARRAY_DECLARATOR);
7569 							}
7570 							AST tmp229_AST = null;
7571 							tmp229_AST = astFactory.create(LT(1));
7572 							astFactory.addASTChild(currentAST, tmp229_AST);
7573 							match(RBRACK);
7574 						}
7575 						else {
7576 							if ( _cnt346>=1 ) { break _loop346; } else {throw new NoViableAltException(LT(1), getFilename());}
7577 						}
7578 						
7579 						_cnt346++;
7580 					} while (true);
7581 					}
7582 					{
7583 					if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
7584 						AST tmp230_AST = null;
7585 						tmp230_AST = astFactory.create(LT(1));
7586 						astFactory.makeASTRoot(currentAST, tmp230_AST);
7587 						match(DOT);
7588 						AST tmp231_AST = null;
7589 						tmp231_AST = astFactory.create(LT(1));
7590 						astFactory.addASTChild(currentAST, tmp231_AST);
7591 						match(LITERAL_class);
7592 					}
7593 					else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
7594 					}
7595 					else {
7596 						throw new NoViableAltException(LT(1), getFilename());
7597 					}
7598 					
7599 					}
7600 				}
7601 				else if ((LA(1)==LBRACK) && (_tokenSet_12.member(LA(2)))) {
7602 					lb = LT(1);
7603 					lb_AST = astFactory.create(lb);
7604 					astFactory.makeASTRoot(currentAST, lb_AST);
7605 					match(LBRACK);
7606 					if ( inputState.guessing==0 ) {
7607 						lb_AST.setType(INDEX_OP);
7608 					}
7609 					expression();
7610 					astFactory.addASTChild(currentAST, returnAST);
7611 					AST tmp232_AST = null;
7612 					tmp232_AST = astFactory.create(LT(1));
7613 					astFactory.addASTChild(currentAST, tmp232_AST);
7614 					match(RBRACK);
7615 				}
7616 				else if ((LA(1)==LPAREN) && (_tokenSet_64.member(LA(2)))) {
7617 					lp = LT(1);
7618 					lp_AST = astFactory.create(lp);
7619 					astFactory.makeASTRoot(currentAST, lp_AST);
7620 					match(LPAREN);
7621 					if ( inputState.guessing==0 ) {
7622 						lp_AST.setType(METHOD_CALL);
7623 					}
7624 					argList();
7625 					astFactory.addASTChild(currentAST, returnAST);
7626 					AST tmp233_AST = null;
7627 					tmp233_AST = astFactory.create(LT(1));
7628 					astFactory.addASTChild(currentAST, tmp233_AST);
7629 					match(RPAREN);
7630 				}
7631 			else {
7632 				break _loop348;
7633 			}
7634 			}
7635 		} while (true);
7636 		}
7637 		{
7638 		if ((LA(1)==INC) && (_tokenSet_62.member(LA(2)))) {
7639 			in = LT(1);
7640 			in_AST = astFactory.create(in);
7641 			astFactory.makeASTRoot(currentAST, in_AST);
7642 			match(INC);
7643 			if ( inputState.guessing==0 ) {
7644 				in_AST.setType(POST_INC);
7645 			}
7646 		}
7647 		else if ((LA(1)==DEC) && (_tokenSet_62.member(LA(2)))) {
7648 			de = LT(1);
7649 			de_AST = astFactory.create(de);
7650 			astFactory.makeASTRoot(currentAST, de_AST);
7651 			match(DEC);
7652 			if ( inputState.guessing==0 ) {
7653 				de_AST.setType(POST_DEC);
7654 			}
7655 		}
7656 		else if ((_tokenSet_62.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
7657 		}
7658 		else {
7659 			throw new NoViableAltException(LT(1), getFilename());
7660 		}
7661 		
7662 		}
7663 		postfixExpression_AST = (AST)currentAST.root;
7664 		returnAST = postfixExpression_AST;
7665 	}
7666 	
7667 /** object instantiation.
7668  *  Trees are built as illustrated by the following input/tree pairs:
7669  *
7670  *  new T()
7671  *
7672  *  new
7673  *   |
7674  *   T --  ELIST
7675  *           |
7676  *          arg1 -- arg2 -- .. -- argn
7677  *
7678  *  new int[]
7679  *
7680  *  new
7681  *   |
7682  *  int -- ARRAY_DECLARATOR
7683  *
7684  *  new int[] {1,2}
7685  *
7686  *  new
7687  *   |
7688  *  int -- ARRAY_DECLARATOR -- ARRAY_INIT
7689  *                                  |
7690  *                                EXPR -- EXPR
7691  *                                  |      |
7692  *                                  1      2
7693  *
7694  *  new int[3]
7695  *  new
7696  *   |
7697  *  int -- ARRAY_DECLARATOR
7698  *                |
7699  *              EXPR
7700  *                |
7701  *                3
7702  *
7703  *  new int[1][2]
7704  *
7705  *  new
7706  *   |
7707  *  int -- ARRAY_DECLARATOR
7708  *               |
7709  *         ARRAY_DECLARATOR -- EXPR
7710  *               |              |
7711  *             EXPR             1
7712  *               |
7713  *               2
7714  *
7715  *
7716  * @throws RecognitionException if recognition problem occurs.
7717  * @throws TokenStreamException if problem occurs while generating a stream of tokens.
7718  */
7719 	public final void newExpression() throws RecognitionException, TokenStreamException {
7720 		
7721 		returnAST = null;
7722 		ASTPair currentAST = new ASTPair();
7723 		AST newExpression_AST = null;
7724 		
7725 		AST tmp234_AST = null;
7726 		tmp234_AST = astFactory.create(LT(1));
7727 		astFactory.makeASTRoot(currentAST, tmp234_AST);
7728 		match(LITERAL_new);
7729 		{
7730 		switch ( LA(1)) {
7731 		case LT:
7732 		{
7733 			typeArguments(false);
7734 			astFactory.addASTChild(currentAST, returnAST);
7735 			break;
7736 		}
7737 		case LITERAL_void:
7738 		case LITERAL_boolean:
7739 		case LITERAL_byte:
7740 		case LITERAL_char:
7741 		case LITERAL_short:
7742 		case LITERAL_int:
7743 		case LITERAL_float:
7744 		case LITERAL_long:
7745 		case LITERAL_double:
7746 		case IDENT:
7747 		case AT:
7748 		{
7749 			break;
7750 		}
7751 		default:
7752 		{
7753 			throw new NoViableAltException(LT(1), getFilename());
7754 		}
7755 		}
7756 		}
7757 		type();
7758 		astFactory.addASTChild(currentAST, returnAST);
7759 		{
7760 		switch ( LA(1)) {
7761 		case LPAREN:
7762 		{
7763 			AST tmp235_AST = null;
7764 			tmp235_AST = astFactory.create(LT(1));
7765 			astFactory.addASTChild(currentAST, tmp235_AST);
7766 			match(LPAREN);
7767 			argList();
7768 			astFactory.addASTChild(currentAST, returnAST);
7769 			AST tmp236_AST = null;
7770 			tmp236_AST = astFactory.create(LT(1));
7771 			astFactory.addASTChild(currentAST, tmp236_AST);
7772 			match(RPAREN);
7773 			{
7774 			if ((LA(1)==LCURLY) && (_tokenSet_28.member(LA(2)))) {
7775 				classBlock();
7776 				astFactory.addASTChild(currentAST, returnAST);
7777 			}
7778 			else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
7779 			}
7780 			else {
7781 				throw new NoViableAltException(LT(1), getFilename());
7782 			}
7783 			
7784 			}
7785 			break;
7786 		}
7787 		case LBRACK:
7788 		{
7789 			newArrayDeclarator();
7790 			astFactory.addASTChild(currentAST, returnAST);
7791 			{
7792 			if ((LA(1)==LCURLY) && (_tokenSet_65.member(LA(2)))) {
7793 				arrayInitializer();
7794 				astFactory.addASTChild(currentAST, returnAST);
7795 			}
7796 			else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
7797 			}
7798 			else {
7799 				throw new NoViableAltException(LT(1), getFilename());
7800 			}
7801 			
7802 			}
7803 			break;
7804 		}
7805 		default:
7806 		{
7807 			throw new NoViableAltException(LT(1), getFilename());
7808 		}
7809 		}
7810 		}
7811 		newExpression_AST = (AST)currentAST.root;
7812 		returnAST = newExpression_AST;
7813 	}
7814 	
7815 	public final void constant() throws RecognitionException, TokenStreamException {
7816 		
7817 		returnAST = null;
7818 		ASTPair currentAST = new ASTPair();
7819 		AST constant_AST = null;
7820 		
7821 		switch ( LA(1)) {
7822 		case NUM_INT:
7823 		{
7824 			AST tmp237_AST = null;
7825 			tmp237_AST = astFactory.create(LT(1));
7826 			astFactory.addASTChild(currentAST, tmp237_AST);
7827 			match(NUM_INT);
7828 			constant_AST = (AST)currentAST.root;
7829 			break;
7830 		}
7831 		case NUM_LONG:
7832 		{
7833 			AST tmp238_AST = null;
7834 			tmp238_AST = astFactory.create(LT(1));
7835 			astFactory.addASTChild(currentAST, tmp238_AST);
7836 			match(NUM_LONG);
7837 			constant_AST = (AST)currentAST.root;
7838 			break;
7839 		}
7840 		case NUM_FLOAT:
7841 		{
7842 			AST tmp239_AST = null;
7843 			tmp239_AST = astFactory.create(LT(1));
7844 			astFactory.addASTChild(currentAST, tmp239_AST);
7845 			match(NUM_FLOAT);
7846 			constant_AST = (AST)currentAST.root;
7847 			break;
7848 		}
7849 		case NUM_DOUBLE:
7850 		{
7851 			AST tmp240_AST = null;
7852 			tmp240_AST = astFactory.create(LT(1));
7853 			astFactory.addASTChild(currentAST, tmp240_AST);
7854 			match(NUM_DOUBLE);
7855 			constant_AST = (AST)currentAST.root;
7856 			break;
7857 		}
7858 		case CHAR_LITERAL:
7859 		{
7860 			AST tmp241_AST = null;
7861 			tmp241_AST = astFactory.create(LT(1));
7862 			astFactory.addASTChild(currentAST, tmp241_AST);
7863 			match(CHAR_LITERAL);
7864 			constant_AST = (AST)currentAST.root;
7865 			break;
7866 		}
7867 		case STRING_LITERAL:
7868 		{
7869 			AST tmp242_AST = null;
7870 			tmp242_AST = astFactory.create(LT(1));
7871 			astFactory.addASTChild(currentAST, tmp242_AST);
7872 			match(STRING_LITERAL);
7873 			constant_AST = (AST)currentAST.root;
7874 			break;
7875 		}
7876 		default:
7877 		{
7878 			throw new NoViableAltException(LT(1), getFilename());
7879 		}
7880 		}
7881 		returnAST = constant_AST;
7882 	}
7883 	
7884 	public final void newArrayDeclarator() throws RecognitionException, TokenStreamException {
7885 		
7886 		returnAST = null;
7887 		ASTPair currentAST = new ASTPair();
7888 		AST newArrayDeclarator_AST = null;
7889 		Token  lb = null;
7890 		AST lb_AST = null;
7891 		
7892 		{
7893 		int _cnt369=0;
7894 		_loop369:
7895 		do {
7896 			if ((LA(1)==LBRACK) && (_tokenSet_66.member(LA(2)))) {
7897 				lb = LT(1);
7898 				lb_AST = astFactory.create(lb);
7899 				astFactory.makeASTRoot(currentAST, lb_AST);
7900 				match(LBRACK);
7901 				if ( inputState.guessing==0 ) {
7902 					lb_AST.setType(ARRAY_DECLARATOR);
7903 				}
7904 				{
7905 				switch ( LA(1)) {
7906 				case LITERAL_void:
7907 				case LITERAL_boolean:
7908 				case LITERAL_byte:
7909 				case LITERAL_char:
7910 				case LITERAL_short:
7911 				case LITERAL_int:
7912 				case LITERAL_float:
7913 				case LITERAL_long:
7914 				case LITERAL_double:
7915 				case IDENT:
7916 				case LPAREN:
7917 				case LITERAL_this:
7918 				case LITERAL_super:
7919 				case PLUS:
7920 				case MINUS:
7921 				case INC:
7922 				case DEC:
7923 				case BNOT:
7924 				case LNOT:
7925 				case LITERAL_true:
7926 				case LITERAL_false:
7927 				case LITERAL_null:
7928 				case LITERAL_new:
7929 				case NUM_INT:
7930 				case CHAR_LITERAL:
7931 				case STRING_LITERAL:
7932 				case NUM_FLOAT:
7933 				case NUM_LONG:
7934 				case NUM_DOUBLE:
7935 				case AT:
7936 				{
7937 					expression();
7938 					astFactory.addASTChild(currentAST, returnAST);
7939 					break;
7940 				}
7941 				case RBRACK:
7942 				{
7943 					break;
7944 				}
7945 				default:
7946 				{
7947 					throw new NoViableAltException(LT(1), getFilename());
7948 				}
7949 				}
7950 				}
7951 				AST tmp243_AST = null;
7952 				tmp243_AST = astFactory.create(LT(1));
7953 				astFactory.addASTChild(currentAST, tmp243_AST);
7954 				match(RBRACK);
7955 			}
7956 			else {
7957 				if ( _cnt369>=1 ) { break _loop369; } else {throw new NoViableAltException(LT(1), getFilename());}
7958 			}
7959 			
7960 			_cnt369++;
7961 		} while (true);
7962 		}
7963 		newArrayDeclarator_AST = (AST)currentAST.root;
7964 		returnAST = newArrayDeclarator_AST;
7965 	}
7966 	
7967 	public final void lambdaParameters() throws RecognitionException, TokenStreamException {
7968 		
7969 		returnAST = null;
7970 		ASTPair currentAST = new ASTPair();
7971 		AST lambdaParameters_AST = null;
7972 		
7973 		switch ( LA(1)) {
7974 		case IDENT:
7975 		{
7976 			AST tmp244_AST = null;
7977 			tmp244_AST = astFactory.create(LT(1));
7978 			astFactory.addASTChild(currentAST, tmp244_AST);
7979 			match(IDENT);
7980 			lambdaParameters_AST = (AST)currentAST.root;
7981 			break;
7982 		}
7983 		case LPAREN:
7984 		{
7985 			AST tmp245_AST = null;
7986 			tmp245_AST = astFactory.create(LT(1));
7987 			astFactory.addASTChild(currentAST, tmp245_AST);
7988 			match(LPAREN);
7989 			{
7990 			if ((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2)))) {
7991 				parameterDeclarationList();
7992 				astFactory.addASTChild(currentAST, returnAST);
7993 			}
7994 			else if ((LA(1)==RPAREN) && (LA(2)==LAMBDA)) {
7995 			}
7996 			else {
7997 				throw new NoViableAltException(LT(1), getFilename());
7998 			}
7999 			
8000 			}
8001 			AST tmp246_AST = null;
8002 			tmp246_AST = astFactory.create(LT(1));
8003 			astFactory.addASTChild(currentAST, tmp246_AST);
8004 			match(RPAREN);
8005 			lambdaParameters_AST = (AST)currentAST.root;
8006 			break;
8007 		}
8008 		default:
8009 		{
8010 			throw new NoViableAltException(LT(1), getFilename());
8011 		}
8012 		}
8013 		returnAST = lambdaParameters_AST;
8014 	}
8015 	
8016 	public final void lambdaBody() throws RecognitionException, TokenStreamException {
8017 		
8018 		returnAST = null;
8019 		ASTPair currentAST = new ASTPair();
8020 		AST lambdaBody_AST = null;
8021 		
8022 		{
8023 		if ((_tokenSet_12.member(LA(1))) && (_tokenSet_69.member(LA(2)))) {
8024 			expression();
8025 			astFactory.addASTChild(currentAST, returnAST);
8026 		}
8027 		else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_69.member(LA(2)))) {
8028 			statement();
8029 			astFactory.addASTChild(currentAST, returnAST);
8030 		}
8031 		else {
8032 			throw new NoViableAltException(LT(1), getFilename());
8033 		}
8034 		
8035 		}
8036 		lambdaBody_AST = (AST)currentAST.root;
8037 		returnAST = lambdaBody_AST;
8038 	}
8039 	
8040 	
8041 	public static final String[] _tokenNames = {
8042 		"<0>",
8043 		"EOF",
8044 		"<2>",
8045 		"NULL_TREE_LOOKAHEAD",
8046 		"BLOCK",
8047 		"MODIFIERS",
8048 		"OBJBLOCK",
8049 		"SLIST",
8050 		"CTOR_DEF",
8051 		"METHOD_DEF",
8052 		"VARIABLE_DEF",
8053 		"INSTANCE_INIT",
8054 		"STATIC_INIT",
8055 		"TYPE",
8056 		"CLASS_DEF",
8057 		"INTERFACE_DEF",
8058 		"PACKAGE_DEF",
8059 		"ARRAY_DECLARATOR",
8060 		"EXTENDS_CLAUSE",
8061 		"IMPLEMENTS_CLAUSE",
8062 		"PARAMETERS",
8063 		"PARAMETER_DEF",
8064 		"LABELED_STAT",
8065 		"TYPECAST",
8066 		"INDEX_OP",
8067 		"POST_INC",
8068 		"POST_DEC",
8069 		"METHOD_CALL",
8070 		"EXPR",
8071 		"ARRAY_INIT",
8072 		"IMPORT",
8073 		"UNARY_MINUS",
8074 		"UNARY_PLUS",
8075 		"CASE_GROUP",
8076 		"ELIST",
8077 		"FOR_INIT",
8078 		"FOR_CONDITION",
8079 		"FOR_ITERATOR",
8080 		"EMPTY_STAT",
8081 		"\"final\"",
8082 		"\"abstract\"",
8083 		"\"strictfp\"",
8084 		"SUPER_CTOR_CALL",
8085 		"CTOR_CALL",
8086 		"\"package\"",
8087 		"SEMI",
8088 		"\"import\"",
8089 		"LBRACK",
8090 		"RBRACK",
8091 		"\"void\"",
8092 		"\"boolean\"",
8093 		"\"byte\"",
8094 		"\"char\"",
8095 		"\"short\"",
8096 		"\"int\"",
8097 		"\"float\"",
8098 		"\"long\"",
8099 		"\"double\"",
8100 		"IDENT",
8101 		"DOT",
8102 		"STAR",
8103 		"\"private\"",
8104 		"\"public\"",
8105 		"\"protected\"",
8106 		"\"static\"",
8107 		"\"transient\"",
8108 		"\"native\"",
8109 		"\"synchronized\"",
8110 		"\"volatile\"",
8111 		"\"class\"",
8112 		"\"extends\"",
8113 		"\"interface\"",
8114 		"LCURLY",
8115 		"RCURLY",
8116 		"COMMA",
8117 		"\"implements\"",
8118 		"LPAREN",
8119 		"RPAREN",
8120 		"\"this\"",
8121 		"\"super\"",
8122 		"ASSIGN",
8123 		"\"throws\"",
8124 		"COLON",
8125 		"\"if\"",
8126 		"\"while\"",
8127 		"\"do\"",
8128 		"\"break\"",
8129 		"\"continue\"",
8130 		"\"return\"",
8131 		"\"switch\"",
8132 		"\"throw\"",
8133 		"\"for\"",
8134 		"\"else\"",
8135 		"\"case\"",
8136 		"\"default\"",
8137 		"\"try\"",
8138 		"\"catch\"",
8139 		"\"finally\"",
8140 		"PLUS_ASSIGN",
8141 		"MINUS_ASSIGN",
8142 		"STAR_ASSIGN",
8143 		"DIV_ASSIGN",
8144 		"MOD_ASSIGN",
8145 		"SR_ASSIGN",
8146 		"BSR_ASSIGN",
8147 		"SL_ASSIGN",
8148 		"BAND_ASSIGN",
8149 		"BXOR_ASSIGN",
8150 		"BOR_ASSIGN",
8151 		"QUESTION",
8152 		"LOR",
8153 		"LAND",
8154 		"BOR",
8155 		"BXOR",
8156 		"BAND",
8157 		"NOT_EQUAL",
8158 		"EQUAL",
8159 		"LT",
8160 		"GT",
8161 		"LE",
8162 		"GE",
8163 		"\"instanceof\"",
8164 		"SL",
8165 		"SR",
8166 		"BSR",
8167 		"PLUS",
8168 		"MINUS",
8169 		"DIV",
8170 		"MOD",
8171 		"INC",
8172 		"DEC",
8173 		"BNOT",
8174 		"LNOT",
8175 		"\"true\"",
8176 		"\"false\"",
8177 		"\"null\"",
8178 		"\"new\"",
8179 		"NUM_INT",
8180 		"CHAR_LITERAL",
8181 		"STRING_LITERAL",
8182 		"NUM_FLOAT",
8183 		"NUM_LONG",
8184 		"NUM_DOUBLE",
8185 		"WS",
8186 		"SINGLE_LINE_COMMENT",
8187 		"BLOCK_COMMENT_BEGIN",
8188 		"ESC",
8189 		"HEX_DIGIT",
8190 		"VOCAB",
8191 		"EXPONENT",
8192 		"FLOAT_SUFFIX",
8193 		"ASSERT",
8194 		"STATIC_IMPORT",
8195 		"ENUM",
8196 		"ENUM_DEF",
8197 		"ENUM_CONSTANT_DEF",
8198 		"FOR_EACH_CLAUSE",
8199 		"ANNOTATION_DEF",
8200 		"ANNOTATIONS",
8201 		"ANNOTATION",
8202 		"ANNOTATION_MEMBER_VALUE_PAIR",
8203 		"ANNOTATION_FIELD_DEF",
8204 		"ANNOTATION_ARRAY_INIT",
8205 		"TYPE_ARGUMENTS",
8206 		"TYPE_ARGUMENT",
8207 		"TYPE_PARAMETERS",
8208 		"TYPE_PARAMETER",
8209 		"WILDCARD_TYPE",
8210 		"TYPE_UPPER_BOUNDS",
8211 		"TYPE_LOWER_BOUNDS",
8212 		"AT",
8213 		"ELLIPSIS",
8214 		"GENERIC_START",
8215 		"GENERIC_END",
8216 		"TYPE_EXTENSION_AND",
8217 		"DO_WHILE",
8218 		"RESOURCE_SPECIFICATION",
8219 		"RESOURCES",
8220 		"RESOURCE",
8221 		"DOUBLE_COLON",
8222 		"METHOD_REF",
8223 		"LAMBDA",
8224 		"BLOCK_COMMENT_END",
8225 		"COMMENT_CONTENT",
8226 		"SINGLE_LINE_COMMENT_CONTENT",
8227 		"BLOCK_COMMENT_CONTENT",
8228 		"STD_ESC",
8229 		"BINARY_DIGIT",
8230 		"ID_START",
8231 		"ID_PART",
8232 		"INT_LITERAL",
8233 		"LONG_LITERAL",
8234 		"FLOAT_LITERAL",
8235 		"DOUBLE_LITERAL",
8236 		"HEX_FLOAT_LITERAL",
8237 		"HEX_DOUBLE_LITERAL",
8238 		"SIGNED_INTEGER",
8239 		"BINARY_EXPONENT"
8240 	};
8241 	
8242 	protected void buildTokenTypeASTClassMap() {
8243 		tokenTypeToASTClassMap=null;
8244 	};
8245 	
8246 	private static final long[] mk_tokenSet_0() {
8247 		long[] data = { -2305733607806730238L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
8248 		return data;
8249 	}
8250 	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
8251 	private static final long[] mk_tokenSet_1() {
8252 		long[] data = { -2017503231655018494L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
8253 		return data;
8254 	}
8255 	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
8256 	private static final long[] mk_tokenSet_2() {
8257 		long[] data = { -2305803976550907904L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
8258 		return data;
8259 	}
8260 	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
8261 	private static final long[] mk_tokenSet_3() {
8262 		long[] data = { -2305803976550907902L, 1073742015L, 4398080065536L, 0L, 0L, 0L};
8263 		return data;
8264 	}
8265 	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
8266 	private static final long[] mk_tokenSet_4() {
8267 		long[] data = { -2305839160922996736L, 1073741855L, 0L, 0L};
8268 		return data;
8269 	}
8270 	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
8271 	private static final long[] mk_tokenSet_5() {
8272 		long[] data = { -101704825569280L, -12885032961L, 2264993995194367L, 0L, 0L, 0L};
8273 		return data;
8274 	}
8275 	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
8276 	private static final long[] mk_tokenSet_6() {
8277 		long[] data = { -84112639524862L, -131073L, 11272193249935359L, 0L, 0L, 0L};
8278 		return data;
8279 	}
8280 	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
8281 	private static final long[] mk_tokenSet_7() {
8282 		long[] data = { 575897802350002176L, 35184372088832L, 4398046511104L, 0L, 0L, 0L};
8283 		return data;
8284 	}
8285 	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
8286 	private static final long[] mk_tokenSet_8() {
8287 		long[] data = { 0L, 1747396655419752448L, 0L, 0L};
8288 		return data;
8289 	}
8290 	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
8291 	private static final long[] mk_tokenSet_9() {
8292 		long[] data = { 575897802350002176L, 0L, 4398046511104L, 0L, 0L, 0L};
8293 		return data;
8294 	}
8295 	public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
8296 	private static final long[] mk_tokenSet_10() {
8297 		long[] data = { 575897802350002176L, 6917529027641135360L, 4398046543870L, 0L, 0L, 0L};
8298 		return data;
8299 	}
8300 	public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
8301 	private static final long[] mk_tokenSet_11() {
8302 		long[] data = { 2305420796748627968L, -35184372026880L, 2256197860229119L, 0L, 0L, 0L};
8303 		return data;
8304 	}
8305 	public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
8306 	private static final long[] mk_tokenSet_12() {
8307 		long[] data = { 575897802350002176L, 6917529027641135104L, 4398046543870L, 0L, 0L, 0L};
8308 		return data;
8309 	}
8310 	public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
8311 	private static final long[] mk_tokenSet_13() {
8312 		long[] data = { 2305455981120716800L, -35184372026368L, 2256197860229119L, 0L, 0L, 0L};
8313 		return data;
8314 	}
8315 	public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
8316 	private static final long[] mk_tokenSet_14() {
8317 		long[] data = { 2305420796748627968L, -35184372034048L, 2256197860229119L, 0L, 0L, 0L};
8318 		return data;
8319 	}
8320 	public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
8321 	private static final long[] mk_tokenSet_15() {
8322 		long[] data = { 575898352105816064L, 24576L, 9011597301252096L, 0L, 0L, 0L};
8323 		return data;
8324 	}
8325 	public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
8326 	private static final long[] mk_tokenSet_16() {
8327 		long[] data = { 2305420796748627968L, -17179488256L, 2256197860229119L, 0L, 0L, 0L};
8328 		return data;
8329 	}
8330 	public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
8331 	private static final long[] mk_tokenSet_17() {
8332 		long[] data = { -101704825569280L, -12885035073L, 2256197902172159L, 0L, 0L, 0L};
8333 		return data;
8334 	}
8335 	public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
8336 	private static final long[] mk_tokenSet_18() {
8337 		long[] data = { 575897802350002176L, 1747396655419755840L, 4398046511104L, 0L, 0L, 0L};
8338 		return data;
8339 	}
8340 	public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
8341 	private static final long[] mk_tokenSet_19() {
8342 		long[] data = { -1153304684409126912L, 9007200328489983L, 4398080065536L, 0L, 0L, 0L};
8343 		return data;
8344 	}
8345 	public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
8346 	private static final long[] mk_tokenSet_20() {
8347 		long[] data = { 0L, 160L, 4398080065536L, 0L, 0L, 0L};
8348 		return data;
8349 	}
8350 	public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
8351 	private static final long[] mk_tokenSet_21() {
8352 		long[] data = { 864831865943490560L, 9007199254740992L, 4398046511104L, 0L, 0L, 0L};
8353 		return data;
8354 	}
8355 	public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
8356 	private static final long[] mk_tokenSet_22() {
8357 		long[] data = { 175921860444160L, 66560L, 0L, 0L};
8358 		return data;
8359 	}
8360 	public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
8361 	private static final long[] mk_tokenSet_23() {
8362 		long[] data = { -1729941358572994560L, 9007200328483007L, 4398080065536L, 0L, 0L, 0L};
8363 		return data;
8364 	}
8365 	public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
8366 	private static final long[] mk_tokenSet_24() {
8367 		long[] data = { -1153339868781215744L, 9007200328487103L, 4398080065536L, 0L, 0L, 0L};
8368 		return data;
8369 	}
8370 	public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
8371 	private static final long[] mk_tokenSet_25() {
8372 		long[] data = { 575897802350002176L, 9007199254740992L, 4398046511104L, 0L, 0L, 0L};
8373 		return data;
8374 	}
8375 	public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
8376 	private static final long[] mk_tokenSet_26() {
8377 		long[] data = { 864831865943490560L, 9007199254745088L, 4398046511104L, 0L, 0L, 0L};
8378 		return data;
8379 	}
8380 	public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
8381 	private static final long[] mk_tokenSet_27() {
8382 		long[] data = { -1729765436712550400L, 9007200328550335L, 4398080065536L, 0L, 0L, 0L};
8383 		return data;
8384 	}
8385 	public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
8386 	private static final long[] mk_tokenSet_28() {
8387 		long[] data = { -1729906174200905728L, 9007200328483775L, 4398080065536L, 0L, 0L, 0L};
8388 		return data;
8389 	}
8390 	public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
8391 	private static final long[] mk_tokenSet_29() {
8392 		long[] data = { -101704825569278L, -12885035073L, 2256197902172159L, 0L, 0L, 0L};
8393 		return data;
8394 	}
8395 	public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
8396 	private static final long[] mk_tokenSet_30() {
8397 		long[] data = { 575898352105816064L, 16384L, 4398046511104L, 0L, 0L, 0L};
8398 		return data;
8399 	}
8400 	public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
8401 	private static final long[] mk_tokenSet_31() {
8402 		long[] data = { 1152499292141780992L, 9007199254766592L, 4398046511104L, 0L, 0L, 0L};
8403 		return data;
8404 	}
8405 	public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
8406 	private static final long[] mk_tokenSet_32() {
8407 		long[] data = { 575898352105816064L, 0L, 4398046511104L, 0L, 0L, 0L};
8408 		return data;
8409 	}
8410 	public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
8411 	private static final long[] mk_tokenSet_33() {
8412 		long[] data = { 1152499292141780992L, 9007199254740992L, 13194139533312L, 0L, 0L, 0L};
8413 		return data;
8414 	}
8415 	public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
8416 	private static final long[] mk_tokenSet_34() {
8417 		long[] data = { 864726312827224064L, 1280L, 0L, 0L};
8418 		return data;
8419 	}
8420 	public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
8421 	private static final long[] mk_tokenSet_35() {
8422 		long[] data = { 576495936675512320L, 1280L, 0L, 0L};
8423 		return data;
8424 	}
8425 	public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
8426 	private static final long[] mk_tokenSet_36() {
8427 		long[] data = { -1729906174200905728L, 6917529031130272063L, 4398054932478L, 0L, 0L, 0L};
8428 		return data;
8429 	}
8430 	public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
8431 	private static final long[] mk_tokenSet_37() {
8432 		long[] data = { 575897802350002176L, 9007199254794240L, 4398046543840L, 0L, 0L, 0L};
8433 		return data;
8434 	}
8435 	public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
8436 	private static final long[] mk_tokenSet_38() {
8437 		long[] data = { 1152499292141780992L, 8673968066687717376L, 4398046543870L, 0L, 0L, 0L};
8438 		return data;
8439 	}
8440 	public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
8441 	private static final long[] mk_tokenSet_39() {
8442 		long[] data = { -1729906174200905728L, 6917529031130272575L, 4398054932478L, 0L, 0L, 0L};
8443 		return data;
8444 	}
8445 	public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
8446 	private static final long[] mk_tokenSet_40() {
8447 		long[] data = { -383179802279936L, -13690342465L, 11263397156913151L, 0L, 0L, 0L};
8448 		return data;
8449 	}
8450 	public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
8451 	private static final long[] mk_tokenSet_41() {
8452 		long[] data = { 0L, 9007199254790144L, 0L, 0L};
8453 		return data;
8454 	}
8455 	public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
8456 	private static final long[] mk_tokenSet_42() {
8457 		long[] data = { 575897802350002176L, 1747431839791894528L, 4398046511104L, 0L, 0L, 0L};
8458 		return data;
8459 	}
8460 	public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
8461 	private static final long[] mk_tokenSet_43() {
8462 		long[] data = { 575897802350002176L, 53248L, 4398046543840L, 0L, 0L, 0L};
8463 		return data;
8464 	}
8465 	public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
8466 	private static final long[] mk_tokenSet_44() {
8467 		long[] data = { 1152499292141780992L, 6926536226895876096L, 4398046543870L, 0L, 0L, 0L};
8468 		return data;
8469 	}
8470 	public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
8471 	private static final long[] mk_tokenSet_45() {
8472 		long[] data = { 2305420796748627968L, -17179742208L, 2256197860229119L, 0L, 0L, 0L};
8473 		return data;
8474 	}
8475 	public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
8476 	private static final long[] mk_tokenSet_46() {
8477 		long[] data = { -84112639524862L, -133185L, 11263397156913151L, 0L, 0L, 0L};
8478 		return data;
8479 	}
8480 	public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
8481 	private static final long[] mk_tokenSet_47() {
8482 		long[] data = { 864831865943490560L, 9007199254757376L, 4398046511104L, 0L, 0L, 0L};
8483 		return data;
8484 	}
8485 	public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
8486 	private static final long[] mk_tokenSet_48() {
8487 		long[] data = { 576601489791778816L, 9216L, 0L, 0L};
8488 		return data;
8489 	}
8490 	public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
8491 	private static final long[] mk_tokenSet_49() {
8492 		long[] data = { -576984669594058752L, -9007194959973569L, 4398054932479L, 0L, 0L, 0L};
8493 		return data;
8494 	}
8495 	public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
8496 	private static final long[] mk_tokenSet_50() {
8497 		long[] data = { -101704825569280L, -133185L, 11263397156913151L, 0L, 0L, 0L};
8498 		return data;
8499 	}
8500 	public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
8501 	private static final long[] mk_tokenSet_51() {
8502 		long[] data = { -1729941358572994560L, 1073741855L, 4398046511104L, 0L, 0L, 0L};
8503 		return data;
8504 	}
8505 	public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
8506 	private static final long[] mk_tokenSet_52() {
8507 		long[] data = { -1153339868781215744L, 9007200328482847L, 4398046511104L, 0L, 0L, 0L};
8508 		return data;
8509 	}
8510 	public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
8511 	private static final long[] mk_tokenSet_53() {
8512 		long[] data = { -383179802279936L, -12885036225L, 11263397123358719L, 0L, 0L, 0L};
8513 		return data;
8514 	}
8515 	public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
8516 	private static final long[] mk_tokenSet_54() {
8517 		long[] data = { -2305839160922996736L, 1073741887L, 4398046511104L, 0L, 0L, 0L};
8518 		return data;
8519 	}
8520 	public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
8521 	private static final long[] mk_tokenSet_55() {
8522 		long[] data = { -2017608784771284992L, 1073741887L, 4398046511104L, 0L, 0L, 0L};
8523 		return data;
8524 	}
8525 	public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
8526 	private static final long[] mk_tokenSet_56() {
8527 		long[] data = { -1729906174200905728L, 6917529028714876959L, 4398046543870L, 0L, 0L, 0L};
8528 		return data;
8529 	}
8530 	public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
8531 	private static final long[] mk_tokenSet_57() {
8532 		long[] data = { -383179802279936L, -16105999329L, 11263397114970111L, 0L, 0L, 0L};
8533 		return data;
8534 	}
8535 	public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
8536 	private static final long[] mk_tokenSet_58() {
8537 		long[] data = { 575897802350002176L, 6917529027641397248L, 4398046543870L, 0L, 0L, 0L};
8538 		return data;
8539 	}
8540 	public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
8541 	private static final long[] mk_tokenSet_59() {
8542 		long[] data = { -383179802279936L, -13153471681L, 11263397123358719L, 0L, 0L, 0L};
8543 		return data;
8544 	}
8545 	public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
8546 	private static final long[] mk_tokenSet_60() {
8547 		long[] data = { 0L, 1610613248L, 0L, 0L};
8548 		return data;
8549 	}
8550 	public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
8551 	private static final long[] mk_tokenSet_61() {
8552 		long[] data = { 2305456530876530688L, -17179741184L, 11263397114970111L, 0L, 0L, 0L};
8553 		return data;
8554 	}
8555 	public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
8556 	private static final long[] mk_tokenSet_62() {
8557 		long[] data = { -576703194617348096L, -12885035073L, 4398088486911L, 0L, 0L, 0L};
8558 		return data;
8559 	}
8560 	public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
8561 	private static final long[] mk_tokenSet_63() {
8562 		long[] data = { 1152921504606846976L, -9223372036854775808L, 1L, 0L, 0L, 0L};
8563 		return data;
8564 	}
8565 	public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
8566 	private static final long[] mk_tokenSet_64() {
8567 		long[] data = { 575897802350002176L, 6917529027641143296L, 4398046543870L, 0L, 0L, 0L};
8568 		return data;
8569 	}
8570 	public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
8571 	private static final long[] mk_tokenSet_65() {
8572 		long[] data = { 575897802350002176L, 6917529027641136896L, 4398046543870L, 0L, 0L, 0L};
8573 		return data;
8574 	}
8575 	public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
8576 	private static final long[] mk_tokenSet_66() {
8577 		long[] data = { 576179277326712832L, 6917529027641135104L, 4398046543870L, 0L, 0L, 0L};
8578 		return data;
8579 	}
8580 	public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
8581 	private static final long[] mk_tokenSet_67() {
8582 		long[] data = { 575898352105816064L, 24576L, 4398046511104L, 0L, 0L, 0L};
8583 		return data;
8584 	}
8585 	public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
8586 	private static final long[] mk_tokenSet_68() {
8587 		long[] data = { 1152499292141780992L, 9007199254766592L, 9020393394274304L, 0L, 0L, 0L};
8588 		return data;
8589 	}
8590 	public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
8591 	private static final long[] mk_tokenSet_69() {
8592 		long[] data = { -101704825569280L, -12885035073L, 11263397156913151L, 0L, 0L, 0L};
8593 		return data;
8594 	}
8595 	public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
8596 	
8597 	}