PreprocessorParser.java

// $ANTLR 3.5.2 PreprocessorParser.g 2023-02-11 20:42:07

package edu.udel.cis.vsl.abc.front.c.preproc;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;


@SuppressWarnings("all")
public class PreprocessorParser extends Parser {
	public static final String[] tokenNames = new String[] {
		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "AMPERSAND", "AND", "ANNOTATION_END", 
		"ANNOTATION_START", "ARROW", "ASSIGN", "AT", "BITANDEQ", "BITOR", "BITOREQ", 
		"BITXOR", "BITXOREQ", "BLOCK_COMMENT", "BinaryExponentPart", "CChar", 
		"CHARACTER_CONSTANT", "COLON", "COMMA", "COMMENT", "DEFINE", "DEFINED", 
		"DIV", "DIVEQ", "DOT", "DOTDOT", "DecimalConstant", "DecimalFloatingConstant", 
		"Digit", "ELIF", "ELLIPSIS", "ELSE", "ENDIF", "EQUALS", "EQUIV_ACSL", 
		"ERROR", "EXTENDED_IDENTIFIER", "EscapeSequence", "ExponentPart", "FLOATING_CONSTANT", 
		"FloatingSuffix", "FractionalConstant", "GT", "GTE", "HASH", "HASHHASH", 
		"HexEscape", "HexFractionalConstant", "HexPrefix", "HexQuad", "HexadecimalConstant", 
		"HexadecimalDigit", "HexadecimalFloatingConstant", "IDENTIFIER", "IF", 
		"IFDEF", "IFNDEF", "IMPLIES", "IMPLIES_ACSL", "INCLUDE", "INLINE_ANNOTATION_START", 
		"INLINE_COMMENT", "INTEGER_CONSTANT", "IdentifierNonDigit", "IntegerSuffix", 
		"LCURLY", "LEXCON", "LINE", "LPAREN", "LSLIST", "LSQUARE", "LT", "LTE", 
		"LongLongSuffix", "LongSuffix", "MINUSMINUS", "MOD", "MODEQ", "NEQ", "NEWLINE", 
		"NOT", "NonDigit", "NonZeroDigit", "OR", "OTHER", "OctalConstant", "OctalDigit", 
		"OctalEscape", "PLUS", "PLUSEQ", "PLUSPLUS", "PP_NUMBER", "PRAGMA", "QMARK", 
		"RCURLY", "REXCON", "RPAREN", "RSLIST", "RSQUARE", "SChar", "SEMI", "SHIFTLEFT", 
		"SHIFTLEFTEQ", "SHIFTRIGHT", "SHIFTRIGHTEQ", "STAR", "STAREQ", "STRING_LITERAL", 
		"SUB", "SUBEQ", "TILDE", "UNDEF", "UniversalCharacterName", "UnsignedSuffix", 
		"WS", "XOR_ACSL", "Zero", "ABSTRACT", "ALIGNAS", "ALIGNOF", "ASM", "ASSIGNS", 
		"ATOMIC", "AUTO", "BIG_O", "BODY", "BOOL", "BREAK", "CALLS", "CASE", "CATCH", 
		"CHAR", "CHOOSE", "CIVLATOMIC", "CIVLFOR", "COLLECTIVE", "COMPLEX", "CONST", 
		"CONTIN", "CONTINUE", "DEFAULT", "DEPENDS", "DERIV", "DEVICE", "DIFFERENTIABLE", 
		"DO", "DOMAIN", "DOUBLE", "ENSURES", "ENUM", "EXISTS", "EXPR", "EXTERN", 
		"FATOMIC", "FILE", "FLOAT", "FOR", "FORALL", "GENERIC", "GLOBAL", "GOTO", 
		"GUARD", "HERE", "IMAGINARY", "INLINE", "INPUT", "INT", "INVARIANT", "LAMBDA", 
		"LONG", "MEM_TYPE", "NORETURN", "ORIGINAL", "OUTPUT", "PARAMLIST", "PARFOR", 
		"PELSE", "PIF", "PPRAGMA", "PROCNULL", "PURE", "RANGE", "READS", "REAL", 
		"REGISTER", "REQUIRES", "RESTRICT", "RESULT", "RETURN", "RUN", "SCOPEOF", 
		"SELF", "SEQUENCE", "SHARED", "SHORT", "SIGNED", "SIZEOF", "SPAWN", "STATE_F", 
		"STATE_NULL", "STATIC", "STATICASSERT", "STRUCT", "SWITCH", "SYSTEM", 
		"TEXT_BLOCK", "THREADLOCAL", "TYPEDEF", "TYPEOF", "UNIFORM", "UNION", 
		"UNSIGNED", "UPDATE", "VALUE_AT", "VOID", "VOLATILE", "WHEN", "WHILE", 
		"WITH"
	};
	public static final int EOF=-1;
	public static final int AMPERSAND=4;
	public static final int AND=5;
	public static final int ANNOTATION_END=6;
	public static final int ANNOTATION_START=7;
	public static final int ARROW=8;
	public static final int ASSIGN=9;
	public static final int AT=10;
	public static final int BITANDEQ=11;
	public static final int BITOR=12;
	public static final int BITOREQ=13;
	public static final int BITXOR=14;
	public static final int BITXOREQ=15;
	public static final int BLOCK_COMMENT=16;
	public static final int BinaryExponentPart=17;
	public static final int CChar=18;
	public static final int CHARACTER_CONSTANT=19;
	public static final int COLON=20;
	public static final int COMMA=21;
	public static final int COMMENT=22;
	public static final int DEFINE=23;
	public static final int DEFINED=24;
	public static final int DIV=25;
	public static final int DIVEQ=26;
	public static final int DOT=27;
	public static final int DOTDOT=28;
	public static final int DecimalConstant=29;
	public static final int DecimalFloatingConstant=30;
	public static final int Digit=31;
	public static final int ELIF=32;
	public static final int ELLIPSIS=33;
	public static final int ELSE=34;
	public static final int ENDIF=35;
	public static final int EQUALS=36;
	public static final int EQUIV_ACSL=37;
	public static final int ERROR=38;
	public static final int EXTENDED_IDENTIFIER=39;
	public static final int EscapeSequence=40;
	public static final int ExponentPart=41;
	public static final int FLOATING_CONSTANT=42;
	public static final int FloatingSuffix=43;
	public static final int FractionalConstant=44;
	public static final int GT=45;
	public static final int GTE=46;
	public static final int HASH=47;
	public static final int HASHHASH=48;
	public static final int HexEscape=49;
	public static final int HexFractionalConstant=50;
	public static final int HexPrefix=51;
	public static final int HexQuad=52;
	public static final int HexadecimalConstant=53;
	public static final int HexadecimalDigit=54;
	public static final int HexadecimalFloatingConstant=55;
	public static final int IDENTIFIER=56;
	public static final int IF=57;
	public static final int IFDEF=58;
	public static final int IFNDEF=59;
	public static final int IMPLIES=60;
	public static final int IMPLIES_ACSL=61;
	public static final int INCLUDE=62;
	public static final int INLINE_ANNOTATION_START=63;
	public static final int INLINE_COMMENT=64;
	public static final int INTEGER_CONSTANT=65;
	public static final int IdentifierNonDigit=66;
	public static final int IntegerSuffix=67;
	public static final int LCURLY=68;
	public static final int LEXCON=69;
	public static final int LINE=70;
	public static final int LPAREN=71;
	public static final int LSLIST=72;
	public static final int LSQUARE=73;
	public static final int LT=74;
	public static final int LTE=75;
	public static final int LongLongSuffix=76;
	public static final int LongSuffix=77;
	public static final int MINUSMINUS=78;
	public static final int MOD=79;
	public static final int MODEQ=80;
	public static final int NEQ=81;
	public static final int NEWLINE=82;
	public static final int NOT=83;
	public static final int NonDigit=84;
	public static final int NonZeroDigit=85;
	public static final int OR=86;
	public static final int OTHER=87;
	public static final int OctalConstant=88;
	public static final int OctalDigit=89;
	public static final int OctalEscape=90;
	public static final int PLUS=91;
	public static final int PLUSEQ=92;
	public static final int PLUSPLUS=93;
	public static final int PP_NUMBER=94;
	public static final int PRAGMA=95;
	public static final int QMARK=96;
	public static final int RCURLY=97;
	public static final int REXCON=98;
	public static final int RPAREN=99;
	public static final int RSLIST=100;
	public static final int RSQUARE=101;
	public static final int SChar=102;
	public static final int SEMI=103;
	public static final int SHIFTLEFT=104;
	public static final int SHIFTLEFTEQ=105;
	public static final int SHIFTRIGHT=106;
	public static final int SHIFTRIGHTEQ=107;
	public static final int STAR=108;
	public static final int STAREQ=109;
	public static final int STRING_LITERAL=110;
	public static final int SUB=111;
	public static final int SUBEQ=112;
	public static final int TILDE=113;
	public static final int UNDEF=114;
	public static final int UniversalCharacterName=115;
	public static final int UnsignedSuffix=116;
	public static final int WS=117;
	public static final int XOR_ACSL=118;
	public static final int Zero=119;
	public static final int ABSTRACT=120;
	public static final int ALIGNAS=121;
	public static final int ALIGNOF=122;
	public static final int ASM=123;
	public static final int ASSIGNS=124;
	public static final int ATOMIC=125;
	public static final int AUTO=126;
	public static final int BIG_O=127;
	public static final int BODY=128;
	public static final int BOOL=129;
	public static final int BREAK=130;
	public static final int CALLS=131;
	public static final int CASE=132;
	public static final int CATCH=133;
	public static final int CHAR=134;
	public static final int CHOOSE=135;
	public static final int CIVLATOMIC=136;
	public static final int CIVLFOR=137;
	public static final int COLLECTIVE=138;
	public static final int COMPLEX=139;
	public static final int CONST=140;
	public static final int CONTIN=141;
	public static final int CONTINUE=142;
	public static final int DEFAULT=143;
	public static final int DEPENDS=144;
	public static final int DERIV=145;
	public static final int DEVICE=146;
	public static final int DIFFERENTIABLE=147;
	public static final int DO=148;
	public static final int DOMAIN=149;
	public static final int DOUBLE=150;
	public static final int ENSURES=151;
	public static final int ENUM=152;
	public static final int EXISTS=153;
	public static final int EXPR=154;
	public static final int EXTERN=155;
	public static final int FATOMIC=156;
	public static final int FILE=157;
	public static final int FLOAT=158;
	public static final int FOR=159;
	public static final int FORALL=160;
	public static final int GENERIC=161;
	public static final int GLOBAL=162;
	public static final int GOTO=163;
	public static final int GUARD=164;
	public static final int HERE=165;
	public static final int IMAGINARY=166;
	public static final int INLINE=167;
	public static final int INPUT=168;
	public static final int INT=169;
	public static final int INVARIANT=170;
	public static final int LAMBDA=171;
	public static final int LONG=172;
	public static final int MEM_TYPE=173;
	public static final int NORETURN=174;
	public static final int ORIGINAL=175;
	public static final int OUTPUT=176;
	public static final int PARAMLIST=177;
	public static final int PARFOR=178;
	public static final int PELSE=179;
	public static final int PIF=180;
	public static final int PPRAGMA=181;
	public static final int PROCNULL=182;
	public static final int PURE=183;
	public static final int RANGE=184;
	public static final int READS=185;
	public static final int REAL=186;
	public static final int REGISTER=187;
	public static final int REQUIRES=188;
	public static final int RESTRICT=189;
	public static final int RESULT=190;
	public static final int RETURN=191;
	public static final int RUN=192;
	public static final int SCOPEOF=193;
	public static final int SELF=194;
	public static final int SEQUENCE=195;
	public static final int SHARED=196;
	public static final int SHORT=197;
	public static final int SIGNED=198;
	public static final int SIZEOF=199;
	public static final int SPAWN=200;
	public static final int STATE_F=201;
	public static final int STATE_NULL=202;
	public static final int STATIC=203;
	public static final int STATICASSERT=204;
	public static final int STRUCT=205;
	public static final int SWITCH=206;
	public static final int SYSTEM=207;
	public static final int TEXT_BLOCK=208;
	public static final int THREADLOCAL=209;
	public static final int TYPEDEF=210;
	public static final int TYPEOF=211;
	public static final int UNIFORM=212;
	public static final int UNION=213;
	public static final int UNSIGNED=214;
	public static final int UPDATE=215;
	public static final int VALUE_AT=216;
	public static final int VOID=217;
	public static final int VOLATILE=218;
	public static final int WHEN=219;
	public static final int WHILE=220;
	public static final int WITH=221;

	// delegates
	public Parser[] getDelegates() {
		return new Parser[] {};
	}

	// delegators


	public PreprocessorParser(TokenStream input) {
		this(input, new RecognizerSharedState());
	}
	public PreprocessorParser(TokenStream input, RecognizerSharedState state) {
		super(input, state);
	}

	protected TreeAdaptor adaptor = new CommonTreeAdaptor();

	public void setTreeAdaptor(TreeAdaptor adaptor) {
		this.adaptor = adaptor;
	}
	public TreeAdaptor getTreeAdaptor() {
		return adaptor;
	}
	@Override public String[] getTokenNames() { return PreprocessorParser.tokenNames; }
	@Override public String getGrammarFileName() { return "PreprocessorParser.g"; }


	@Override
	public void emitErrorMessage(String msg) { // don't try to recover!
	    throw new RuntimeException(msg);
	}


	public static class file_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "file"
	// PreprocessorParser.g:157:1: file : ( whiteBlock )? itemList EOF -> ^( FILE ( whiteBlock )? itemList EOF ) ;
	public final PreprocessorParser.file_return file() throws RecognitionException {
		PreprocessorParser.file_return retval = new PreprocessorParser.file_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token EOF3=null;
		ParserRuleReturnScope whiteBlock1 =null;
		ParserRuleReturnScope itemList2 =null;

		Object EOF3_tree=null;
		RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
		RewriteRuleSubtreeStream stream_whiteBlock=new RewriteRuleSubtreeStream(adaptor,"rule whiteBlock");
		RewriteRuleSubtreeStream stream_itemList=new RewriteRuleSubtreeStream(adaptor,"rule itemList");

		try {
			// PreprocessorParser.g:157:7: ( ( whiteBlock )? itemList EOF -> ^( FILE ( whiteBlock )? itemList EOF ) )
			// PreprocessorParser.g:157:9: ( whiteBlock )? itemList EOF
			{
			// PreprocessorParser.g:157:9: ( whiteBlock )?
			int alt1=2;
			int LA1_0 = input.LA(1);
			if ( (LA1_0==COMMENT||LA1_0==WS) ) {
				alt1=1;
			}
			switch (alt1) {
				case 1 :
					// PreprocessorParser.g:157:9: whiteBlock
					{
					pushFollow(FOLLOW_whiteBlock_in_file546);
					whiteBlock1=whiteBlock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_whiteBlock.add(whiteBlock1.getTree());
					}
					break;

			}

			pushFollow(FOLLOW_itemList_in_file549);
			itemList2=itemList();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_itemList.add(itemList2.getTree());
			EOF3=(Token)match(input,EOF,FOLLOW_EOF_in_file551); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_EOF.add(EOF3);

			// AST REWRITE
			// elements: itemList, whiteBlock, EOF
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 158:5: -> ^( FILE ( whiteBlock )? itemList EOF )
			{
				// PreprocessorParser.g:158:8: ^( FILE ( whiteBlock )? itemList EOF )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FILE, "FILE"), root_1);
				// PreprocessorParser.g:158:15: ( whiteBlock )?
				if ( stream_whiteBlock.hasNext() ) {
					adaptor.addChild(root_1, stream_whiteBlock.nextTree());
				}
				stream_whiteBlock.reset();

				adaptor.addChild(root_1, stream_itemList.nextTree());
				adaptor.addChild(root_1, stream_EOF.nextNode());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "file"


	public static class itemList_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "itemList"
	// PreprocessorParser.g:170:1: itemList : ( directiveBlock itemList | textBlock ( directiveBlock itemList |) |);
	public final PreprocessorParser.itemList_return itemList() throws RecognitionException {
		PreprocessorParser.itemList_return retval = new PreprocessorParser.itemList_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope directiveBlock4 =null;
		ParserRuleReturnScope itemList5 =null;
		ParserRuleReturnScope textBlock6 =null;
		ParserRuleReturnScope directiveBlock7 =null;
		ParserRuleReturnScope itemList8 =null;


		try {
			// PreprocessorParser.g:170:10: ( directiveBlock itemList | textBlock ( directiveBlock itemList |) |)
			int alt3=3;
			switch ( input.LA(1) ) {
			case HASH:
				{
				alt3=1;
				}
				break;
			case AMPERSAND:
			case AND:
			case ANNOTATION_END:
			case ANNOTATION_START:
			case ARROW:
			case ASSIGN:
			case AT:
			case BITANDEQ:
			case BITOR:
			case BITOREQ:
			case BITXOR:
			case BITXOREQ:
			case BLOCK_COMMENT:
			case BinaryExponentPart:
			case CChar:
			case CHARACTER_CONSTANT:
			case COLON:
			case COMMA:
			case DEFINE:
			case DEFINED:
			case DIV:
			case DIVEQ:
			case DOT:
			case DOTDOT:
			case DecimalConstant:
			case DecimalFloatingConstant:
			case Digit:
			case ELIF:
			case ELLIPSIS:
			case ELSE:
			case ENDIF:
			case EQUALS:
			case EQUIV_ACSL:
			case ERROR:
			case EXTENDED_IDENTIFIER:
			case EscapeSequence:
			case ExponentPart:
			case FLOATING_CONSTANT:
			case FloatingSuffix:
			case FractionalConstant:
			case GT:
			case GTE:
			case HASHHASH:
			case HexEscape:
			case HexFractionalConstant:
			case HexPrefix:
			case HexQuad:
			case HexadecimalConstant:
			case HexadecimalDigit:
			case HexadecimalFloatingConstant:
			case IDENTIFIER:
			case IF:
			case IFDEF:
			case IFNDEF:
			case IMPLIES:
			case IMPLIES_ACSL:
			case INCLUDE:
			case INLINE_ANNOTATION_START:
			case INLINE_COMMENT:
			case INTEGER_CONSTANT:
			case IdentifierNonDigit:
			case IntegerSuffix:
			case LCURLY:
			case LEXCON:
			case LINE:
			case LPAREN:
			case LSLIST:
			case LSQUARE:
			case LT:
			case LTE:
			case LongLongSuffix:
			case LongSuffix:
			case MINUSMINUS:
			case MOD:
			case MODEQ:
			case NEQ:
			case NEWLINE:
			case NOT:
			case NonDigit:
			case NonZeroDigit:
			case OR:
			case OTHER:
			case OctalConstant:
			case OctalDigit:
			case OctalEscape:
			case PLUS:
			case PLUSEQ:
			case PLUSPLUS:
			case PP_NUMBER:
			case PRAGMA:
			case QMARK:
			case RCURLY:
			case REXCON:
			case RPAREN:
			case RSLIST:
			case RSQUARE:
			case SChar:
			case SEMI:
			case SHIFTLEFT:
			case SHIFTLEFTEQ:
			case SHIFTRIGHT:
			case SHIFTRIGHTEQ:
			case STAR:
			case STAREQ:
			case STRING_LITERAL:
			case SUB:
			case SUBEQ:
			case TILDE:
			case UNDEF:
			case UniversalCharacterName:
			case UnsignedSuffix:
			case XOR_ACSL:
			case Zero:
			case ABSTRACT:
			case ALIGNAS:
			case ALIGNOF:
			case ASM:
			case ASSIGNS:
			case ATOMIC:
			case AUTO:
			case BIG_O:
			case BODY:
			case BOOL:
			case BREAK:
			case CALLS:
			case CASE:
			case CATCH:
			case CHAR:
			case CHOOSE:
			case CIVLATOMIC:
			case CIVLFOR:
			case COLLECTIVE:
			case COMPLEX:
			case CONST:
			case CONTIN:
			case CONTINUE:
			case DEFAULT:
			case DEPENDS:
			case DERIV:
			case DEVICE:
			case DIFFERENTIABLE:
			case DO:
			case DOMAIN:
			case DOUBLE:
			case ENSURES:
			case ENUM:
			case EXISTS:
			case EXPR:
			case EXTERN:
			case FATOMIC:
			case FILE:
			case FLOAT:
			case FOR:
			case FORALL:
			case GENERIC:
			case GLOBAL:
			case GOTO:
			case GUARD:
			case HERE:
			case IMAGINARY:
			case INLINE:
			case INPUT:
			case INT:
			case INVARIANT:
			case LAMBDA:
			case LONG:
			case MEM_TYPE:
			case NORETURN:
			case ORIGINAL:
			case OUTPUT:
			case PARAMLIST:
			case PARFOR:
			case PELSE:
			case PIF:
			case PPRAGMA:
			case PROCNULL:
			case PURE:
			case RANGE:
			case READS:
			case REAL:
			case REGISTER:
			case REQUIRES:
			case RESTRICT:
			case RESULT:
			case RETURN:
			case RUN:
			case SCOPEOF:
			case SELF:
			case SEQUENCE:
			case SHARED:
			case SHORT:
			case SIGNED:
			case SIZEOF:
			case SPAWN:
			case STATE_F:
			case STATE_NULL:
			case STATIC:
			case STATICASSERT:
			case STRUCT:
			case SWITCH:
			case SYSTEM:
			case TEXT_BLOCK:
			case THREADLOCAL:
			case TYPEDEF:
			case TYPEOF:
			case UNIFORM:
			case UNION:
			case UNSIGNED:
			case UPDATE:
			case VALUE_AT:
			case VOID:
			case VOLATILE:
			case WHEN:
			case WHILE:
			case WITH:
				{
				alt3=2;
				}
				break;
			case EOF:
				{
				alt3=3;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 3, 0, input);
				throw nvae;
			}
			switch (alt3) {
				case 1 :
					// PreprocessorParser.g:170:12: directiveBlock itemList
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_directiveBlock_in_itemList584);
					directiveBlock4=directiveBlock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, directiveBlock4.getTree());

					pushFollow(FOLLOW_itemList_in_itemList586);
					itemList5=itemList();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, itemList5.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:171:5: textBlock ( directiveBlock itemList |)
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_textBlock_in_itemList592);
					textBlock6=textBlock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, textBlock6.getTree());

					// PreprocessorParser.g:171:15: ( directiveBlock itemList |)
					int alt2=2;
					int LA2_0 = input.LA(1);
					if ( (LA2_0==HASH) ) {
						alt2=1;
					}
					else if ( (LA2_0==EOF) ) {
						alt2=2;
					}

					else {
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae =
							new NoViableAltException("", 2, 0, input);
						throw nvae;
					}

					switch (alt2) {
						case 1 :
							// PreprocessorParser.g:171:17: directiveBlock itemList
							{
							pushFollow(FOLLOW_directiveBlock_in_itemList596);
							directiveBlock7=directiveBlock();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) adaptor.addChild(root_0, directiveBlock7.getTree());

							pushFollow(FOLLOW_itemList_in_itemList598);
							itemList8=itemList();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) adaptor.addChild(root_0, itemList8.getTree());

							}
							break;
						case 2 :
							// PreprocessorParser.g:171:43: 
							{
							}
							break;

					}

					}
					break;
				case 3 :
					// PreprocessorParser.g:173:3: 
					{
					root_0 = (Object)adaptor.nil();


					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "itemList"


	public static class whiteBlock_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "whiteBlock"
	// PreprocessorParser.g:175:1: whiteBlock : ( white )+ -> ^( TEXT_BLOCK ( white )+ ) ;
	public final PreprocessorParser.whiteBlock_return whiteBlock() throws RecognitionException {
		PreprocessorParser.whiteBlock_return retval = new PreprocessorParser.whiteBlock_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope white9 =null;

		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");

		try {
			// PreprocessorParser.g:175:12: ( ( white )+ -> ^( TEXT_BLOCK ( white )+ ) )
			// PreprocessorParser.g:175:14: ( white )+
			{
			// PreprocessorParser.g:175:14: ( white )+
			int cnt4=0;
			loop4:
			while (true) {
				int alt4=2;
				int LA4_0 = input.LA(1);
				if ( (LA4_0==COMMENT||LA4_0==WS) ) {
					alt4=1;
				}

				switch (alt4) {
				case 1 :
					// PreprocessorParser.g:175:14: white
					{
					pushFollow(FOLLOW_white_in_whiteBlock617);
					white9=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white9.getTree());
					}
					break;

				default :
					if ( cnt4 >= 1 ) break loop4;
					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee = new EarlyExitException(4, input);
					throw eee;
				}
				cnt4++;
			}

			// AST REWRITE
			// elements: white
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 175:21: -> ^( TEXT_BLOCK ( white )+ )
			{
				// PreprocessorParser.g:175:24: ^( TEXT_BLOCK ( white )+ )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TEXT_BLOCK, "TEXT_BLOCK"), root_1);
				if ( !(stream_white.hasNext()) ) {
					throw new RewriteEarlyExitException();
				}
				while ( stream_white.hasNext() ) {
					adaptor.addChild(root_1, stream_white.nextTree());
				}
				stream_white.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "whiteBlock"


	public static class textBlock_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "textBlock"
	// PreprocessorParser.g:178:1: textBlock : ( textSegment )+ -> ^( TEXT_BLOCK ( textSegment )+ ) ;
	public final PreprocessorParser.textBlock_return textBlock() throws RecognitionException {
		PreprocessorParser.textBlock_return retval = new PreprocessorParser.textBlock_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope textSegment10 =null;

		RewriteRuleSubtreeStream stream_textSegment=new RewriteRuleSubtreeStream(adaptor,"rule textSegment");

		try {
			// PreprocessorParser.g:178:11: ( ( textSegment )+ -> ^( TEXT_BLOCK ( textSegment )+ ) )
			// PreprocessorParser.g:178:13: ( textSegment )+
			{
			// PreprocessorParser.g:178:13: ( textSegment )+
			int cnt5=0;
			loop5:
			while (true) {
				int alt5=2;
				int LA5_0 = input.LA(1);
				if ( ((LA5_0 >= AMPERSAND && LA5_0 <= COMMA)||(LA5_0 >= DEFINE && LA5_0 <= GTE)||(LA5_0 >= HASHHASH && LA5_0 <= UnsignedSuffix)||(LA5_0 >= XOR_ACSL && LA5_0 <= WITH)) ) {
					alt5=1;
				}

				switch (alt5) {
				case 1 :
					// PreprocessorParser.g:178:13: textSegment
					{
					pushFollow(FOLLOW_textSegment_in_textBlock638);
					textSegment10=textSegment();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_textSegment.add(textSegment10.getTree());
					}
					break;

				default :
					if ( cnt5 >= 1 ) break loop5;
					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee = new EarlyExitException(5, input);
					throw eee;
				}
				cnt5++;
			}

			// AST REWRITE
			// elements: textSegment
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 178:26: -> ^( TEXT_BLOCK ( textSegment )+ )
			{
				// PreprocessorParser.g:178:29: ^( TEXT_BLOCK ( textSegment )+ )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(TEXT_BLOCK, "TEXT_BLOCK"), root_1);
				if ( !(stream_textSegment.hasNext()) ) {
					throw new RewriteEarlyExitException();
				}
				while ( stream_textSegment.hasNext() ) {
					adaptor.addChild(root_1, stream_textSegment.nextTree());
				}
				stream_textSegment.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "textBlock"


	public static class textSegment_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "textSegment"
	// PreprocessorParser.g:181:1: textSegment : ( NEWLINE ( white )* |~ ( HASH | WS | COMMENT | NEWLINE ) (~ NEWLINE )* NEWLINE ( white )* );
	public final PreprocessorParser.textSegment_return textSegment() throws RecognitionException {
		PreprocessorParser.textSegment_return retval = new PreprocessorParser.textSegment_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token NEWLINE11=null;
		Token set13=null;
		Token set14=null;
		Token NEWLINE15=null;
		ParserRuleReturnScope white12 =null;
		ParserRuleReturnScope white16 =null;

		Object NEWLINE11_tree=null;
		Object set13_tree=null;
		Object set14_tree=null;
		Object NEWLINE15_tree=null;

		try {
			// PreprocessorParser.g:181:13: ( NEWLINE ( white )* |~ ( HASH | WS | COMMENT | NEWLINE ) (~ NEWLINE )* NEWLINE ( white )* )
			int alt9=2;
			int LA9_0 = input.LA(1);
			if ( (LA9_0==NEWLINE) ) {
				alt9=1;
			}
			else if ( ((LA9_0 >= AMPERSAND && LA9_0 <= COMMA)||(LA9_0 >= DEFINE && LA9_0 <= GTE)||(LA9_0 >= HASHHASH && LA9_0 <= NEQ)||(LA9_0 >= NOT && LA9_0 <= UnsignedSuffix)||(LA9_0 >= XOR_ACSL && LA9_0 <= WITH)) ) {
				alt9=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 9, 0, input);
				throw nvae;
			}

			switch (alt9) {
				case 1 :
					// PreprocessorParser.g:181:15: NEWLINE ( white )*
					{
					root_0 = (Object)adaptor.nil();


					NEWLINE11=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_textSegment659); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					NEWLINE11_tree = (Object)adaptor.create(NEWLINE11);
					adaptor.addChild(root_0, NEWLINE11_tree);
					}

					// PreprocessorParser.g:181:23: ( white )*
					loop6:
					while (true) {
						int alt6=2;
						int LA6_0 = input.LA(1);
						if ( (LA6_0==COMMENT||LA6_0==WS) ) {
							alt6=1;
						}

						switch (alt6) {
						case 1 :
							// PreprocessorParser.g:181:23: white
							{
							pushFollow(FOLLOW_white_in_textSegment661);
							white12=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) adaptor.addChild(root_0, white12.getTree());

							}
							break;

						default :
							break loop6;
						}
					}

					}
					break;
				case 2 :
					// PreprocessorParser.g:182:5: ~ ( HASH | WS | COMMENT | NEWLINE ) (~ NEWLINE )* NEWLINE ( white )*
					{
					root_0 = (Object)adaptor.nil();


					set13=input.LT(1);
					if ( (input.LA(1) >= AMPERSAND && input.LA(1) <= COMMA)||(input.LA(1) >= DEFINE && input.LA(1) <= GTE)||(input.LA(1) >= HASHHASH && input.LA(1) <= NEQ)||(input.LA(1) >= NOT && input.LA(1) <= UnsignedSuffix)||(input.LA(1) >= XOR_ACSL && input.LA(1) <= WITH) ) {
						input.consume();
						if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set13));
						state.errorRecovery=false;
						state.failed=false;
					}
					else {
						if (state.backtracking>0) {state.failed=true; return retval;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						throw mse;
					}
					// PreprocessorParser.g:182:32: (~ NEWLINE )*
					loop7:
					while (true) {
						int alt7=2;
						int LA7_0 = input.LA(1);
						if ( ((LA7_0 >= AMPERSAND && LA7_0 <= NEQ)||(LA7_0 >= NOT && LA7_0 <= WITH)) ) {
							alt7=1;
						}

						switch (alt7) {
						case 1 :
							// PreprocessorParser.g:
							{
							set14=input.LT(1);
							if ( (input.LA(1) >= AMPERSAND && input.LA(1) <= NEQ)||(input.LA(1) >= NOT && input.LA(1) <= WITH) ) {
								input.consume();
								if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set14));
								state.errorRecovery=false;
								state.failed=false;
							}
							else {
								if (state.backtracking>0) {state.failed=true; return retval;}
								MismatchedSetException mse = new MismatchedSetException(null,input);
								throw mse;
							}
							}
							break;

						default :
							break loop7;
						}
					}

					NEWLINE15=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_textSegment685); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					NEWLINE15_tree = (Object)adaptor.create(NEWLINE15);
					adaptor.addChild(root_0, NEWLINE15_tree);
					}

					// PreprocessorParser.g:182:52: ( white )*
					loop8:
					while (true) {
						int alt8=2;
						int LA8_0 = input.LA(1);
						if ( (LA8_0==COMMENT||LA8_0==WS) ) {
							alt8=1;
						}

						switch (alt8) {
						case 1 :
							// PreprocessorParser.g:182:52: white
							{
							pushFollow(FOLLOW_white_in_textSegment687);
							white16=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) adaptor.addChild(root_0, white16.getTree());

							}
							break;

						default :
							break loop8;
						}
					}

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "textSegment"


	public static class directiveBlock_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "directiveBlock"
	// PreprocessorParser.g:185:1: directiveBlock : directive ( whiteBlock )? ;
	public final PreprocessorParser.directiveBlock_return directiveBlock() throws RecognitionException {
		PreprocessorParser.directiveBlock_return retval = new PreprocessorParser.directiveBlock_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope directive17 =null;
		ParserRuleReturnScope whiteBlock18 =null;


		try {
			// PreprocessorParser.g:185:16: ( directive ( whiteBlock )? )
			// PreprocessorParser.g:185:18: directive ( whiteBlock )?
			{
			root_0 = (Object)adaptor.nil();


			pushFollow(FOLLOW_directive_in_directiveBlock699);
			directive17=directive();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, directive17.getTree());

			// PreprocessorParser.g:185:28: ( whiteBlock )?
			int alt10=2;
			int LA10_0 = input.LA(1);
			if ( (LA10_0==COMMENT||LA10_0==WS) ) {
				alt10=1;
			}
			switch (alt10) {
				case 1 :
					// PreprocessorParser.g:185:28: whiteBlock
					{
					pushFollow(FOLLOW_whiteBlock_in_directiveBlock701);
					whiteBlock18=whiteBlock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, whiteBlock18.getTree());

					}
					break;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "directiveBlock"


	public static class directive_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "directive"
	// PreprocessorParser.g:188:1: directive : HASH ! ( white !)* directiveSuffix ;
	public final PreprocessorParser.directive_return directive() throws RecognitionException {
		PreprocessorParser.directive_return retval = new PreprocessorParser.directive_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token HASH19=null;
		ParserRuleReturnScope white20 =null;
		ParserRuleReturnScope directiveSuffix21 =null;

		Object HASH19_tree=null;

		try {
			// PreprocessorParser.g:188:11: ( HASH ! ( white !)* directiveSuffix )
			// PreprocessorParser.g:188:13: HASH ! ( white !)* directiveSuffix
			{
			root_0 = (Object)adaptor.nil();


			HASH19=(Token)match(input,HASH,FOLLOW_HASH_in_directive713); if (state.failed) return retval;
			// PreprocessorParser.g:188:24: ( white !)*
			loop11:
			while (true) {
				int alt11=2;
				int LA11_0 = input.LA(1);
				if ( (LA11_0==COMMENT||LA11_0==WS) ) {
					alt11=1;
				}

				switch (alt11) {
				case 1 :
					// PreprocessorParser.g:188:24: white !
					{
					pushFollow(FOLLOW_white_in_directive716);
					white20=white();
					state._fsp--;
					if (state.failed) return retval;
					}
					break;

				default :
					break loop11;
				}
			}

			pushFollow(FOLLOW_directiveSuffix_in_directive720);
			directiveSuffix21=directiveSuffix();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, directiveSuffix21.getTree());

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "directive"


	public static class directiveSuffix_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "directiveSuffix"
	// PreprocessorParser.g:191:1: directiveSuffix : ( macrodef | macroundef | includeline | pragmaline | errorline | lineline | ifdefblock | ifblock | ifndefblock | nondirective );
	public final PreprocessorParser.directiveSuffix_return directiveSuffix() throws RecognitionException {
		PreprocessorParser.directiveSuffix_return retval = new PreprocessorParser.directiveSuffix_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope macrodef22 =null;
		ParserRuleReturnScope macroundef23 =null;
		ParserRuleReturnScope includeline24 =null;
		ParserRuleReturnScope pragmaline25 =null;
		ParserRuleReturnScope errorline26 =null;
		ParserRuleReturnScope lineline27 =null;
		ParserRuleReturnScope ifdefblock28 =null;
		ParserRuleReturnScope ifblock29 =null;
		ParserRuleReturnScope ifndefblock30 =null;
		ParserRuleReturnScope nondirective31 =null;


		try {
			// PreprocessorParser.g:191:17: ( macrodef | macroundef | includeline | pragmaline | errorline | lineline | ifdefblock | ifblock | ifndefblock | nondirective )
			int alt12=10;
			switch ( input.LA(1) ) {
			case DEFINE:
				{
				alt12=1;
				}
				break;
			case UNDEF:
				{
				alt12=2;
				}
				break;
			case INCLUDE:
				{
				alt12=3;
				}
				break;
			case PRAGMA:
				{
				alt12=4;
				}
				break;
			case ERROR:
				{
				alt12=5;
				}
				break;
			case LINE:
				{
				alt12=6;
				}
				break;
			case IFDEF:
				{
				alt12=7;
				}
				break;
			case IF:
				{
				alt12=8;
				}
				break;
			case IFNDEF:
				{
				alt12=9;
				}
				break;
			case AMPERSAND:
			case AND:
			case ANNOTATION_END:
			case ANNOTATION_START:
			case ARROW:
			case ASSIGN:
			case AT:
			case BITANDEQ:
			case BITOR:
			case BITOREQ:
			case BITXOR:
			case BITXOREQ:
			case CHARACTER_CONSTANT:
			case COLON:
			case COMMA:
			case DIV:
			case DIVEQ:
			case DOT:
			case DOTDOT:
			case ELLIPSIS:
			case EQUALS:
			case EQUIV_ACSL:
			case EXTENDED_IDENTIFIER:
			case FLOATING_CONSTANT:
			case GT:
			case GTE:
			case HASH:
			case HASHHASH:
			case IDENTIFIER:
			case IMPLIES:
			case IMPLIES_ACSL:
			case INLINE_ANNOTATION_START:
			case INTEGER_CONSTANT:
			case LCURLY:
			case LEXCON:
			case LPAREN:
			case LSLIST:
			case LSQUARE:
			case LT:
			case LTE:
			case MINUSMINUS:
			case MOD:
			case MODEQ:
			case NEQ:
			case NEWLINE:
			case NOT:
			case OR:
			case OTHER:
			case PLUS:
			case PLUSEQ:
			case PLUSPLUS:
			case PP_NUMBER:
			case QMARK:
			case RCURLY:
			case REXCON:
			case RPAREN:
			case RSLIST:
			case RSQUARE:
			case SEMI:
			case SHIFTLEFT:
			case SHIFTLEFTEQ:
			case SHIFTRIGHT:
			case SHIFTRIGHTEQ:
			case STAR:
			case STAREQ:
			case STRING_LITERAL:
			case SUB:
			case SUBEQ:
			case TILDE:
			case XOR_ACSL:
				{
				alt12=10;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 12, 0, input);
				throw nvae;
			}
			switch (alt12) {
				case 1 :
					// PreprocessorParser.g:191:19: macrodef
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_macrodef_in_directiveSuffix731);
					macrodef22=macrodef();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, macrodef22.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:192:5: macroundef
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_macroundef_in_directiveSuffix737);
					macroundef23=macroundef();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, macroundef23.getTree());

					}
					break;
				case 3 :
					// PreprocessorParser.g:193:5: includeline
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_includeline_in_directiveSuffix743);
					includeline24=includeline();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, includeline24.getTree());

					}
					break;
				case 4 :
					// PreprocessorParser.g:194:5: pragmaline
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_pragmaline_in_directiveSuffix749);
					pragmaline25=pragmaline();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, pragmaline25.getTree());

					}
					break;
				case 5 :
					// PreprocessorParser.g:195:5: errorline
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_errorline_in_directiveSuffix755);
					errorline26=errorline();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, errorline26.getTree());

					}
					break;
				case 6 :
					// PreprocessorParser.g:196:5: lineline
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_lineline_in_directiveSuffix761);
					lineline27=lineline();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, lineline27.getTree());

					}
					break;
				case 7 :
					// PreprocessorParser.g:197:5: ifdefblock
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_ifdefblock_in_directiveSuffix767);
					ifdefblock28=ifdefblock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, ifdefblock28.getTree());

					}
					break;
				case 8 :
					// PreprocessorParser.g:198:5: ifblock
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_ifblock_in_directiveSuffix773);
					ifblock29=ifblock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, ifblock29.getTree());

					}
					break;
				case 9 :
					// PreprocessorParser.g:199:5: ifndefblock
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_ifndefblock_in_directiveSuffix779);
					ifndefblock30=ifndefblock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, ifndefblock30.getTree());

					}
					break;
				case 10 :
					// PreprocessorParser.g:200:5: nondirective
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_nondirective_in_directiveSuffix785);
					nondirective31=nondirective();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, nondirective31.getTree());

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "directiveSuffix"


	public static class nondirective_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "nondirective"
	// PreprocessorParser.g:206:1: nondirective : (t+= not_directive (t+= wpptoken )* NEWLINE -> ^( HASH ( $t)+ ) | NEWLINE -> ^( HASH ) );
	public final PreprocessorParser.nondirective_return nondirective() throws RecognitionException {
		PreprocessorParser.nondirective_return retval = new PreprocessorParser.nondirective_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token NEWLINE32=null;
		Token NEWLINE33=null;
		List<Object> list_t=null;
		RuleReturnScope t = null;
		Object NEWLINE32_tree=null;
		Object NEWLINE33_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleSubtreeStream stream_not_directive=new RewriteRuleSubtreeStream(adaptor,"rule not_directive");
		RewriteRuleSubtreeStream stream_wpptoken=new RewriteRuleSubtreeStream(adaptor,"rule wpptoken");

		try {
			// PreprocessorParser.g:206:14: (t+= not_directive (t+= wpptoken )* NEWLINE -> ^( HASH ( $t)+ ) | NEWLINE -> ^( HASH ) )
			int alt14=2;
			int LA14_0 = input.LA(1);
			if ( ((LA14_0 >= AMPERSAND && LA14_0 <= BITXOREQ)||(LA14_0 >= CHARACTER_CONSTANT && LA14_0 <= COMMA)||(LA14_0 >= DIV && LA14_0 <= DOTDOT)||LA14_0==ELLIPSIS||(LA14_0 >= EQUALS && LA14_0 <= EQUIV_ACSL)||LA14_0==EXTENDED_IDENTIFIER||LA14_0==FLOATING_CONSTANT||(LA14_0 >= GT && LA14_0 <= HASHHASH)||LA14_0==IDENTIFIER||(LA14_0 >= IMPLIES && LA14_0 <= IMPLIES_ACSL)||LA14_0==INLINE_ANNOTATION_START||LA14_0==INTEGER_CONSTANT||(LA14_0 >= LCURLY && LA14_0 <= LEXCON)||(LA14_0 >= LPAREN && LA14_0 <= LTE)||(LA14_0 >= MINUSMINUS && LA14_0 <= NEQ)||LA14_0==NOT||(LA14_0 >= OR && LA14_0 <= OTHER)||(LA14_0 >= PLUS && LA14_0 <= PP_NUMBER)||(LA14_0 >= QMARK && LA14_0 <= RSQUARE)||(LA14_0 >= SEMI && LA14_0 <= TILDE)||LA14_0==XOR_ACSL) ) {
				alt14=1;
			}
			else if ( (LA14_0==NEWLINE) ) {
				alt14=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 14, 0, input);
				throw nvae;
			}

			switch (alt14) {
				case 1 :
					// PreprocessorParser.g:206:16: t+= not_directive (t+= wpptoken )* NEWLINE
					{
					pushFollow(FOLLOW_not_directive_in_nondirective800);
					t=not_directive();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_not_directive.add(t.getTree());
					if (list_t==null) list_t=new ArrayList<Object>();
					list_t.add(t.getTree());
					// PreprocessorParser.g:206:34: (t+= wpptoken )*
					loop13:
					while (true) {
						int alt13=2;
						int LA13_0 = input.LA(1);
						if ( ((LA13_0 >= AMPERSAND && LA13_0 <= BITXOREQ)||(LA13_0 >= CHARACTER_CONSTANT && LA13_0 <= DOTDOT)||(LA13_0 >= ELIF && LA13_0 <= EXTENDED_IDENTIFIER)||LA13_0==FLOATING_CONSTANT||(LA13_0 >= GT && LA13_0 <= HASHHASH)||(LA13_0 >= IDENTIFIER && LA13_0 <= INLINE_ANNOTATION_START)||LA13_0==INTEGER_CONSTANT||(LA13_0 >= LCURLY && LA13_0 <= LTE)||(LA13_0 >= MINUSMINUS && LA13_0 <= NEQ)||LA13_0==NOT||(LA13_0 >= OR && LA13_0 <= OTHER)||(LA13_0 >= PLUS && LA13_0 <= RSQUARE)||(LA13_0 >= SEMI && LA13_0 <= UNDEF)||(LA13_0 >= WS && LA13_0 <= XOR_ACSL)) ) {
							alt13=1;
						}

						switch (alt13) {
						case 1 :
							// PreprocessorParser.g:206:34: t+= wpptoken
							{
							pushFollow(FOLLOW_wpptoken_in_nondirective804);
							t=wpptoken();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_wpptoken.add(t.getTree());
							if (list_t==null) list_t=new ArrayList<Object>();
							list_t.add(t.getTree());
							}
							break;

						default :
							break loop13;
						}
					}

					NEWLINE32=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_nondirective807); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE32);

					// AST REWRITE
					// elements: t
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: t
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
					RewriteRuleSubtreeStream stream_t=new RewriteRuleSubtreeStream(adaptor,"token t",list_t);
					root_0 = (Object)adaptor.nil();
					// 206:54: -> ^( HASH ( $t)+ )
					{
						// PreprocessorParser.g:206:57: ^( HASH ( $t)+ )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(HASH, "HASH"), root_1);
						if ( !(stream_t.hasNext()) ) {
							throw new RewriteEarlyExitException();
						}
						while ( stream_t.hasNext() ) {
							adaptor.addChild(root_1, stream_t.nextTree());
						}
						stream_t.reset();

						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 2 :
					// PreprocessorParser.g:207:5: NEWLINE
					{
					NEWLINE33=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_nondirective823); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE33);

					// AST REWRITE
					// elements: 
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 207:13: -> ^( HASH )
					{
						// PreprocessorParser.g:207:16: ^( HASH )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(HASH, "HASH"), root_1);
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "nondirective"


	public static class macrodef_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "macrodef"
	// PreprocessorParser.g:211:1: macrodef : DEFINE ( white )+ i= identifier ( paramlist macrobody -> ^( DEFINE $i paramlist macrobody ) | NEWLINE -> ^( DEFINE $i ^( BODY ) ) | white macrobody -> ^( DEFINE $i macrobody ) ) ;
	public final PreprocessorParser.macrodef_return macrodef() throws RecognitionException {
		PreprocessorParser.macrodef_return retval = new PreprocessorParser.macrodef_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token DEFINE34=null;
		Token NEWLINE38=null;
		ParserRuleReturnScope i =null;
		ParserRuleReturnScope white35 =null;
		ParserRuleReturnScope paramlist36 =null;
		ParserRuleReturnScope macrobody37 =null;
		ParserRuleReturnScope white39 =null;
		ParserRuleReturnScope macrobody40 =null;

		Object DEFINE34_tree=null;
		Object NEWLINE38_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_DEFINE=new RewriteRuleTokenStream(adaptor,"token DEFINE");
		RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");
		RewriteRuleSubtreeStream stream_paramlist=new RewriteRuleSubtreeStream(adaptor,"rule paramlist");
		RewriteRuleSubtreeStream stream_macrobody=new RewriteRuleSubtreeStream(adaptor,"rule macrobody");

		try {
			// PreprocessorParser.g:211:10: ( DEFINE ( white )+ i= identifier ( paramlist macrobody -> ^( DEFINE $i paramlist macrobody ) | NEWLINE -> ^( DEFINE $i ^( BODY ) ) | white macrobody -> ^( DEFINE $i macrobody ) ) )
			// PreprocessorParser.g:211:12: DEFINE ( white )+ i= identifier ( paramlist macrobody -> ^( DEFINE $i paramlist macrobody ) | NEWLINE -> ^( DEFINE $i ^( BODY ) ) | white macrobody -> ^( DEFINE $i macrobody ) )
			{
			DEFINE34=(Token)match(input,DEFINE,FOLLOW_DEFINE_in_macrodef842); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_DEFINE.add(DEFINE34);

			// PreprocessorParser.g:211:19: ( white )+
			int cnt15=0;
			loop15:
			while (true) {
				int alt15=2;
				int LA15_0 = input.LA(1);
				if ( (LA15_0==COMMENT||LA15_0==WS) ) {
					alt15=1;
				}

				switch (alt15) {
				case 1 :
					// PreprocessorParser.g:211:19: white
					{
					pushFollow(FOLLOW_white_in_macrodef844);
					white35=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white35.getTree());
					}
					break;

				default :
					if ( cnt15 >= 1 ) break loop15;
					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee = new EarlyExitException(15, input);
					throw eee;
				}
				cnt15++;
			}

			pushFollow(FOLLOW_identifier_in_macrodef849);
			i=identifier();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_identifier.add(i.getTree());
			// PreprocessorParser.g:212:5: ( paramlist macrobody -> ^( DEFINE $i paramlist macrobody ) | NEWLINE -> ^( DEFINE $i ^( BODY ) ) | white macrobody -> ^( DEFINE $i macrobody ) )
			int alt16=3;
			switch ( input.LA(1) ) {
			case LPAREN:
				{
				alt16=1;
				}
				break;
			case NEWLINE:
				{
				alt16=2;
				}
				break;
			case COMMENT:
			case WS:
				{
				alt16=3;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 16, 0, input);
				throw nvae;
			}
			switch (alt16) {
				case 1 :
					// PreprocessorParser.g:212:7: paramlist macrobody
					{
					pushFollow(FOLLOW_paramlist_in_macrodef857);
					paramlist36=paramlist();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_paramlist.add(paramlist36.getTree());
					pushFollow(FOLLOW_macrobody_in_macrodef859);
					macrobody37=macrobody();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_macrobody.add(macrobody37.getTree());
					// AST REWRITE
					// elements: i, DEFINE, paramlist, macrobody
					// token labels: 
					// rule labels: i, retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_i=new RewriteRuleSubtreeStream(adaptor,"rule i",i!=null?i.getTree():null);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 212:27: -> ^( DEFINE $i paramlist macrobody )
					{
						// PreprocessorParser.g:212:30: ^( DEFINE $i paramlist macrobody )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_DEFINE.nextNode(), root_1);
						adaptor.addChild(root_1, stream_i.nextTree());
						adaptor.addChild(root_1, stream_paramlist.nextTree());
						adaptor.addChild(root_1, stream_macrobody.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 2 :
					// PreprocessorParser.g:213:7: NEWLINE
					{
					NEWLINE38=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_macrodef880); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE38);

					// AST REWRITE
					// elements: DEFINE, i
					// token labels: 
					// rule labels: i, retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_i=new RewriteRuleSubtreeStream(adaptor,"rule i",i!=null?i.getTree():null);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 213:15: -> ^( DEFINE $i ^( BODY ) )
					{
						// PreprocessorParser.g:213:18: ^( DEFINE $i ^( BODY ) )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_DEFINE.nextNode(), root_1);
						adaptor.addChild(root_1, stream_i.nextTree());
						// PreprocessorParser.g:213:30: ^( BODY )
						{
						Object root_2 = (Object)adaptor.nil();
						root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(BODY, "BODY"), root_2);
						adaptor.addChild(root_1, root_2);
						}

						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 3 :
					// PreprocessorParser.g:214:7: white macrobody
					{
					pushFollow(FOLLOW_white_in_macrodef901);
					white39=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white39.getTree());
					pushFollow(FOLLOW_macrobody_in_macrodef903);
					macrobody40=macrobody();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_macrobody.add(macrobody40.getTree());
					// AST REWRITE
					// elements: DEFINE, i, macrobody
					// token labels: 
					// rule labels: i, retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_i=new RewriteRuleSubtreeStream(adaptor,"rule i",i!=null?i.getTree():null);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 214:23: -> ^( DEFINE $i macrobody )
					{
						// PreprocessorParser.g:214:26: ^( DEFINE $i macrobody )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_DEFINE.nextNode(), root_1);
						adaptor.addChild(root_1, stream_i.nextTree());
						adaptor.addChild(root_1, stream_macrobody.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "macrodef"


	public static class macrobody_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "macrobody"
	// PreprocessorParser.g:218:1: macrobody : ( white )* (t+= pptoken ( (t+= wpptoken )* t+= pptoken )? ( white )* NEWLINE -> ^( BODY ( $t)+ ) | NEWLINE -> ^( BODY ) ) ;
	public final PreprocessorParser.macrobody_return macrobody() throws RecognitionException {
		PreprocessorParser.macrobody_return retval = new PreprocessorParser.macrobody_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token NEWLINE43=null;
		Token NEWLINE44=null;
		List<Object> list_t=null;
		ParserRuleReturnScope white41 =null;
		ParserRuleReturnScope white42 =null;
		RuleReturnScope t = null;
		Object NEWLINE43_tree=null;
		Object NEWLINE44_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");
		RewriteRuleSubtreeStream stream_pptoken=new RewriteRuleSubtreeStream(adaptor,"rule pptoken");
		RewriteRuleSubtreeStream stream_wpptoken=new RewriteRuleSubtreeStream(adaptor,"rule wpptoken");

		try {
			// PreprocessorParser.g:218:11: ( ( white )* (t+= pptoken ( (t+= wpptoken )* t+= pptoken )? ( white )* NEWLINE -> ^( BODY ( $t)+ ) | NEWLINE -> ^( BODY ) ) )
			// PreprocessorParser.g:218:13: ( white )* (t+= pptoken ( (t+= wpptoken )* t+= pptoken )? ( white )* NEWLINE -> ^( BODY ( $t)+ ) | NEWLINE -> ^( BODY ) )
			{
			// PreprocessorParser.g:218:13: ( white )*
			loop17:
			while (true) {
				int alt17=2;
				int LA17_0 = input.LA(1);
				if ( (LA17_0==COMMENT||LA17_0==WS) ) {
					alt17=1;
				}

				switch (alt17) {
				case 1 :
					// PreprocessorParser.g:218:13: white
					{
					pushFollow(FOLLOW_white_in_macrobody931);
					white41=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white41.getTree());
					}
					break;

				default :
					break loop17;
				}
			}

			// PreprocessorParser.g:219:5: (t+= pptoken ( (t+= wpptoken )* t+= pptoken )? ( white )* NEWLINE -> ^( BODY ( $t)+ ) | NEWLINE -> ^( BODY ) )
			int alt21=2;
			int LA21_0 = input.LA(1);
			if ( ((LA21_0 >= AMPERSAND && LA21_0 <= BITXOREQ)||(LA21_0 >= CHARACTER_CONSTANT && LA21_0 <= COMMA)||(LA21_0 >= DEFINE && LA21_0 <= DOTDOT)||(LA21_0 >= ELIF && LA21_0 <= EXTENDED_IDENTIFIER)||LA21_0==FLOATING_CONSTANT||(LA21_0 >= GT && LA21_0 <= HASHHASH)||(LA21_0 >= IDENTIFIER && LA21_0 <= INLINE_ANNOTATION_START)||LA21_0==INTEGER_CONSTANT||(LA21_0 >= LCURLY && LA21_0 <= LTE)||(LA21_0 >= MINUSMINUS && LA21_0 <= NEQ)||LA21_0==NOT||(LA21_0 >= OR && LA21_0 <= OTHER)||(LA21_0 >= PLUS && LA21_0 <= RSQUARE)||(LA21_0 >= SEMI && LA21_0 <= UNDEF)||LA21_0==XOR_ACSL) ) {
				alt21=1;
			}
			else if ( (LA21_0==NEWLINE) ) {
				alt21=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 21, 0, input);
				throw nvae;
			}

			switch (alt21) {
				case 1 :
					// PreprocessorParser.g:219:7: t+= pptoken ( (t+= wpptoken )* t+= pptoken )? ( white )* NEWLINE
					{
					pushFollow(FOLLOW_pptoken_in_macrobody943);
					t=pptoken();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_pptoken.add(t.getTree());
					if (list_t==null) list_t=new ArrayList<Object>();
					list_t.add(t.getTree());
					// PreprocessorParser.g:219:18: ( (t+= wpptoken )* t+= pptoken )?
					int alt19=2;
					alt19 = dfa19.predict(input);
					switch (alt19) {
						case 1 :
							// PreprocessorParser.g:219:19: (t+= wpptoken )* t+= pptoken
							{
							// PreprocessorParser.g:219:20: (t+= wpptoken )*
							loop18:
							while (true) {
								int alt18=2;
								alt18 = dfa18.predict(input);
								switch (alt18) {
								case 1 :
									// PreprocessorParser.g:219:20: t+= wpptoken
									{
									pushFollow(FOLLOW_wpptoken_in_macrobody948);
									t=wpptoken();
									state._fsp--;
									if (state.failed) return retval;
									if ( state.backtracking==0 ) stream_wpptoken.add(t.getTree());
									if (list_t==null) list_t=new ArrayList<Object>();
									list_t.add(t.getTree());
									}
									break;

								default :
									break loop18;
								}
							}

							pushFollow(FOLLOW_pptoken_in_macrobody953);
							t=pptoken();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_pptoken.add(t.getTree());
							if (list_t==null) list_t=new ArrayList<Object>();
							list_t.add(t.getTree());
							}
							break;

					}

					// PreprocessorParser.g:219:45: ( white )*
					loop20:
					while (true) {
						int alt20=2;
						int LA20_0 = input.LA(1);
						if ( (LA20_0==COMMENT||LA20_0==WS) ) {
							alt20=1;
						}

						switch (alt20) {
						case 1 :
							// PreprocessorParser.g:219:45: white
							{
							pushFollow(FOLLOW_white_in_macrobody957);
							white42=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white42.getTree());
							}
							break;

						default :
							break loop20;
						}
					}

					NEWLINE43=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_macrobody960); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE43);

					// AST REWRITE
					// elements: t
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: t
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
					RewriteRuleSubtreeStream stream_t=new RewriteRuleSubtreeStream(adaptor,"token t",list_t);
					root_0 = (Object)adaptor.nil();
					// 220:7: -> ^( BODY ( $t)+ )
					{
						// PreprocessorParser.g:220:10: ^( BODY ( $t)+ )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(BODY, "BODY"), root_1);
						if ( !(stream_t.hasNext()) ) {
							throw new RewriteEarlyExitException();
						}
						while ( stream_t.hasNext() ) {
							adaptor.addChild(root_1, stream_t.nextTree());
						}
						stream_t.reset();

						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 2 :
					// PreprocessorParser.g:221:7: NEWLINE
					{
					NEWLINE44=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_macrobody984); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE44);

					// AST REWRITE
					// elements: 
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 221:15: -> ^( BODY )
					{
						// PreprocessorParser.g:221:18: ^( BODY )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(BODY, "BODY"), root_1);
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "macrobody"


	public static class paramlist_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "paramlist"
	// PreprocessorParser.g:225:1: paramlist : LPAREN ( white )* ( RPAREN -> ^( PARAMLIST ) | ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ELLIPSIS ) | identifier ( ( white )* COMMA ( white )* identifier )* ( white )* ( RPAREN -> ^( PARAMLIST ( identifier )+ ) | COMMA ( white )* ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ( identifier )+ ELLIPSIS ) ) ) ;
	public final PreprocessorParser.paramlist_return paramlist() throws RecognitionException {
		PreprocessorParser.paramlist_return retval = new PreprocessorParser.paramlist_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token LPAREN45=null;
		Token RPAREN47=null;
		Token ELLIPSIS48=null;
		Token RPAREN50=null;
		Token COMMA53=null;
		Token RPAREN57=null;
		Token COMMA58=null;
		Token ELLIPSIS60=null;
		Token RPAREN62=null;
		ParserRuleReturnScope white46 =null;
		ParserRuleReturnScope white49 =null;
		ParserRuleReturnScope identifier51 =null;
		ParserRuleReturnScope white52 =null;
		ParserRuleReturnScope white54 =null;
		ParserRuleReturnScope identifier55 =null;
		ParserRuleReturnScope white56 =null;
		ParserRuleReturnScope white59 =null;
		ParserRuleReturnScope white61 =null;

		Object LPAREN45_tree=null;
		Object RPAREN47_tree=null;
		Object ELLIPSIS48_tree=null;
		Object RPAREN50_tree=null;
		Object COMMA53_tree=null;
		Object RPAREN57_tree=null;
		Object COMMA58_tree=null;
		Object ELLIPSIS60_tree=null;
		Object RPAREN62_tree=null;
		RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
		RewriteRuleTokenStream stream_ELLIPSIS=new RewriteRuleTokenStream(adaptor,"token ELLIPSIS");
		RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
		RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
		RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");

		try {
			// PreprocessorParser.g:225:11: ( LPAREN ( white )* ( RPAREN -> ^( PARAMLIST ) | ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ELLIPSIS ) | identifier ( ( white )* COMMA ( white )* identifier )* ( white )* ( RPAREN -> ^( PARAMLIST ( identifier )+ ) | COMMA ( white )* ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ( identifier )+ ELLIPSIS ) ) ) )
			// PreprocessorParser.g:225:13: LPAREN ( white )* ( RPAREN -> ^( PARAMLIST ) | ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ELLIPSIS ) | identifier ( ( white )* COMMA ( white )* identifier )* ( white )* ( RPAREN -> ^( PARAMLIST ( identifier )+ ) | COMMA ( white )* ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ( identifier )+ ELLIPSIS ) ) )
			{
			LPAREN45=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_paramlist1007); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_LPAREN.add(LPAREN45);

			// PreprocessorParser.g:225:20: ( white )*
			loop22:
			while (true) {
				int alt22=2;
				int LA22_0 = input.LA(1);
				if ( (LA22_0==COMMENT||LA22_0==WS) ) {
					alt22=1;
				}

				switch (alt22) {
				case 1 :
					// PreprocessorParser.g:225:20: white
					{
					pushFollow(FOLLOW_white_in_paramlist1009);
					white46=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white46.getTree());
					}
					break;

				default :
					break loop22;
				}
			}

			// PreprocessorParser.g:226:5: ( RPAREN -> ^( PARAMLIST ) | ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ELLIPSIS ) | identifier ( ( white )* COMMA ( white )* identifier )* ( white )* ( RPAREN -> ^( PARAMLIST ( identifier )+ ) | COMMA ( white )* ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ( identifier )+ ELLIPSIS ) ) )
			int alt31=3;
			switch ( input.LA(1) ) {
			case RPAREN:
				{
				alt31=1;
				}
				break;
			case ELLIPSIS:
				{
				alt31=2;
				}
				break;
			case DEFINE:
			case DEFINED:
			case ELIF:
			case ELSE:
			case ENDIF:
			case ERROR:
			case EXTENDED_IDENTIFIER:
			case IDENTIFIER:
			case IF:
			case IFDEF:
			case IFNDEF:
			case INCLUDE:
			case LINE:
			case PRAGMA:
			case UNDEF:
				{
				alt31=3;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 31, 0, input);
				throw nvae;
			}
			switch (alt31) {
				case 1 :
					// PreprocessorParser.g:226:7: RPAREN
					{
					RPAREN47=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_paramlist1019); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN47);

					// AST REWRITE
					// elements: 
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 226:14: -> ^( PARAMLIST )
					{
						// PreprocessorParser.g:226:17: ^( PARAMLIST )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMLIST, "PARAMLIST"), root_1);
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 2 :
					// PreprocessorParser.g:227:7: ELLIPSIS ( white )* RPAREN
					{
					ELLIPSIS48=(Token)match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_paramlist1033); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_ELLIPSIS.add(ELLIPSIS48);

					// PreprocessorParser.g:227:16: ( white )*
					loop23:
					while (true) {
						int alt23=2;
						int LA23_0 = input.LA(1);
						if ( (LA23_0==COMMENT||LA23_0==WS) ) {
							alt23=1;
						}

						switch (alt23) {
						case 1 :
							// PreprocessorParser.g:227:16: white
							{
							pushFollow(FOLLOW_white_in_paramlist1035);
							white49=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white49.getTree());
							}
							break;

						default :
							break loop23;
						}
					}

					RPAREN50=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_paramlist1038); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN50);

					// AST REWRITE
					// elements: ELLIPSIS
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 227:30: -> ^( PARAMLIST ELLIPSIS )
					{
						// PreprocessorParser.g:227:33: ^( PARAMLIST ELLIPSIS )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMLIST, "PARAMLIST"), root_1);
						adaptor.addChild(root_1, stream_ELLIPSIS.nextNode());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 3 :
					// PreprocessorParser.g:228:7: identifier ( ( white )* COMMA ( white )* identifier )* ( white )* ( RPAREN -> ^( PARAMLIST ( identifier )+ ) | COMMA ( white )* ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ( identifier )+ ELLIPSIS ) )
					{
					pushFollow(FOLLOW_identifier_in_paramlist1054);
					identifier51=identifier();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_identifier.add(identifier51.getTree());
					// PreprocessorParser.g:228:18: ( ( white )* COMMA ( white )* identifier )*
					loop26:
					while (true) {
						int alt26=2;
						alt26 = dfa26.predict(input);
						switch (alt26) {
						case 1 :
							// PreprocessorParser.g:228:19: ( white )* COMMA ( white )* identifier
							{
							// PreprocessorParser.g:228:19: ( white )*
							loop24:
							while (true) {
								int alt24=2;
								int LA24_0 = input.LA(1);
								if ( (LA24_0==COMMENT||LA24_0==WS) ) {
									alt24=1;
								}

								switch (alt24) {
								case 1 :
									// PreprocessorParser.g:228:19: white
									{
									pushFollow(FOLLOW_white_in_paramlist1057);
									white52=white();
									state._fsp--;
									if (state.failed) return retval;
									if ( state.backtracking==0 ) stream_white.add(white52.getTree());
									}
									break;

								default :
									break loop24;
								}
							}

							COMMA53=(Token)match(input,COMMA,FOLLOW_COMMA_in_paramlist1060); if (state.failed) return retval; 
							if ( state.backtracking==0 ) stream_COMMA.add(COMMA53);

							// PreprocessorParser.g:228:32: ( white )*
							loop25:
							while (true) {
								int alt25=2;
								int LA25_0 = input.LA(1);
								if ( (LA25_0==COMMENT||LA25_0==WS) ) {
									alt25=1;
								}

								switch (alt25) {
								case 1 :
									// PreprocessorParser.g:228:32: white
									{
									pushFollow(FOLLOW_white_in_paramlist1062);
									white54=white();
									state._fsp--;
									if (state.failed) return retval;
									if ( state.backtracking==0 ) stream_white.add(white54.getTree());
									}
									break;

								default :
									break loop25;
								}
							}

							pushFollow(FOLLOW_identifier_in_paramlist1065);
							identifier55=identifier();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_identifier.add(identifier55.getTree());
							}
							break;

						default :
							break loop26;
						}
					}

					// PreprocessorParser.g:228:52: ( white )*
					loop27:
					while (true) {
						int alt27=2;
						int LA27_0 = input.LA(1);
						if ( (LA27_0==COMMENT||LA27_0==WS) ) {
							alt27=1;
						}

						switch (alt27) {
						case 1 :
							// PreprocessorParser.g:228:52: white
							{
							pushFollow(FOLLOW_white_in_paramlist1069);
							white56=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white56.getTree());
							}
							break;

						default :
							break loop27;
						}
					}

					// PreprocessorParser.g:229:7: ( RPAREN -> ^( PARAMLIST ( identifier )+ ) | COMMA ( white )* ELLIPSIS ( white )* RPAREN -> ^( PARAMLIST ( identifier )+ ELLIPSIS ) )
					int alt30=2;
					int LA30_0 = input.LA(1);
					if ( (LA30_0==RPAREN) ) {
						alt30=1;
					}
					else if ( (LA30_0==COMMA) ) {
						alt30=2;
					}

					else {
						if (state.backtracking>0) {state.failed=true; return retval;}
						NoViableAltException nvae =
							new NoViableAltException("", 30, 0, input);
						throw nvae;
					}

					switch (alt30) {
						case 1 :
							// PreprocessorParser.g:229:9: RPAREN
							{
							RPAREN57=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_paramlist1080); if (state.failed) return retval; 
							if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN57);

							// AST REWRITE
							// elements: identifier
							// token labels: 
							// rule labels: retval
							// token list labels: 
							// rule list labels: 
							// wildcard labels: 
							if ( state.backtracking==0 ) {
							retval.tree = root_0;
							RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

							root_0 = (Object)adaptor.nil();
							// 229:16: -> ^( PARAMLIST ( identifier )+ )
							{
								// PreprocessorParser.g:229:19: ^( PARAMLIST ( identifier )+ )
								{
								Object root_1 = (Object)adaptor.nil();
								root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMLIST, "PARAMLIST"), root_1);
								if ( !(stream_identifier.hasNext()) ) {
									throw new RewriteEarlyExitException();
								}
								while ( stream_identifier.hasNext() ) {
									adaptor.addChild(root_1, stream_identifier.nextTree());
								}
								stream_identifier.reset();

								adaptor.addChild(root_0, root_1);
								}

							}


							retval.tree = root_0;
							}

							}
							break;
						case 2 :
							// PreprocessorParser.g:230:9: COMMA ( white )* ELLIPSIS ( white )* RPAREN
							{
							COMMA58=(Token)match(input,COMMA,FOLLOW_COMMA_in_paramlist1099); if (state.failed) return retval; 
							if ( state.backtracking==0 ) stream_COMMA.add(COMMA58);

							// PreprocessorParser.g:230:15: ( white )*
							loop28:
							while (true) {
								int alt28=2;
								int LA28_0 = input.LA(1);
								if ( (LA28_0==COMMENT||LA28_0==WS) ) {
									alt28=1;
								}

								switch (alt28) {
								case 1 :
									// PreprocessorParser.g:230:15: white
									{
									pushFollow(FOLLOW_white_in_paramlist1101);
									white59=white();
									state._fsp--;
									if (state.failed) return retval;
									if ( state.backtracking==0 ) stream_white.add(white59.getTree());
									}
									break;

								default :
									break loop28;
								}
							}

							ELLIPSIS60=(Token)match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_paramlist1104); if (state.failed) return retval; 
							if ( state.backtracking==0 ) stream_ELLIPSIS.add(ELLIPSIS60);

							// PreprocessorParser.g:230:31: ( white )*
							loop29:
							while (true) {
								int alt29=2;
								int LA29_0 = input.LA(1);
								if ( (LA29_0==COMMENT||LA29_0==WS) ) {
									alt29=1;
								}

								switch (alt29) {
								case 1 :
									// PreprocessorParser.g:230:31: white
									{
									pushFollow(FOLLOW_white_in_paramlist1106);
									white61=white();
									state._fsp--;
									if (state.failed) return retval;
									if ( state.backtracking==0 ) stream_white.add(white61.getTree());
									}
									break;

								default :
									break loop29;
								}
							}

							RPAREN62=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_paramlist1109); if (state.failed) return retval; 
							if ( state.backtracking==0 ) stream_RPAREN.add(RPAREN62);

							// AST REWRITE
							// elements: ELLIPSIS, identifier
							// token labels: 
							// rule labels: retval
							// token list labels: 
							// rule list labels: 
							// wildcard labels: 
							if ( state.backtracking==0 ) {
							retval.tree = root_0;
							RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

							root_0 = (Object)adaptor.nil();
							// 231:9: -> ^( PARAMLIST ( identifier )+ ELLIPSIS )
							{
								// PreprocessorParser.g:231:12: ^( PARAMLIST ( identifier )+ ELLIPSIS )
								{
								Object root_1 = (Object)adaptor.nil();
								root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARAMLIST, "PARAMLIST"), root_1);
								if ( !(stream_identifier.hasNext()) ) {
									throw new RewriteEarlyExitException();
								}
								while ( stream_identifier.hasNext() ) {
									adaptor.addChild(root_1, stream_identifier.nextTree());
								}
								stream_identifier.reset();

								adaptor.addChild(root_1, stream_ELLIPSIS.nextNode());
								adaptor.addChild(root_0, root_1);
								}

							}


							retval.tree = root_0;
							}

							}
							break;

					}

					}
					break;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "paramlist"


	public static class macroundef_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "macroundef"
	// PreprocessorParser.g:236:1: macroundef : UNDEF ( white )+ identifier ( white )* NEWLINE -> ^( UNDEF identifier ) ;
	public final PreprocessorParser.macroundef_return macroundef() throws RecognitionException {
		PreprocessorParser.macroundef_return retval = new PreprocessorParser.macroundef_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token UNDEF63=null;
		Token NEWLINE67=null;
		ParserRuleReturnScope white64 =null;
		ParserRuleReturnScope identifier65 =null;
		ParserRuleReturnScope white66 =null;

		Object UNDEF63_tree=null;
		Object NEWLINE67_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_UNDEF=new RewriteRuleTokenStream(adaptor,"token UNDEF");
		RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");

		try {
			// PreprocessorParser.g:236:12: ( UNDEF ( white )+ identifier ( white )* NEWLINE -> ^( UNDEF identifier ) )
			// PreprocessorParser.g:236:14: UNDEF ( white )+ identifier ( white )* NEWLINE
			{
			UNDEF63=(Token)match(input,UNDEF,FOLLOW_UNDEF_in_macroundef1153); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_UNDEF.add(UNDEF63);

			// PreprocessorParser.g:236:20: ( white )+
			int cnt32=0;
			loop32:
			while (true) {
				int alt32=2;
				int LA32_0 = input.LA(1);
				if ( (LA32_0==COMMENT||LA32_0==WS) ) {
					alt32=1;
				}

				switch (alt32) {
				case 1 :
					// PreprocessorParser.g:236:20: white
					{
					pushFollow(FOLLOW_white_in_macroundef1155);
					white64=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white64.getTree());
					}
					break;

				default :
					if ( cnt32 >= 1 ) break loop32;
					if (state.backtracking>0) {state.failed=true; return retval;}
					EarlyExitException eee = new EarlyExitException(32, input);
					throw eee;
				}
				cnt32++;
			}

			pushFollow(FOLLOW_identifier_in_macroundef1158);
			identifier65=identifier();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_identifier.add(identifier65.getTree());
			// PreprocessorParser.g:236:38: ( white )*
			loop33:
			while (true) {
				int alt33=2;
				int LA33_0 = input.LA(1);
				if ( (LA33_0==COMMENT||LA33_0==WS) ) {
					alt33=1;
				}

				switch (alt33) {
				case 1 :
					// PreprocessorParser.g:236:38: white
					{
					pushFollow(FOLLOW_white_in_macroundef1160);
					white66=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white66.getTree());
					}
					break;

				default :
					break loop33;
				}
			}

			NEWLINE67=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_macroundef1163); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE67);

			// AST REWRITE
			// elements: identifier, UNDEF
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 237:5: -> ^( UNDEF identifier )
			{
				// PreprocessorParser.g:237:8: ^( UNDEF identifier )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_UNDEF.nextNode(), root_1);
				adaptor.addChild(root_1, stream_identifier.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "macroundef"


	public static class includeline_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "includeline"
	// PreprocessorParser.g:240:1: includeline : INCLUDE ( white )* t+= pptoken ( (t+= wpptoken )* t+= pptoken )? ( white )* NEWLINE -> ^( INCLUDE ( $t)+ ) ;
	public final PreprocessorParser.includeline_return includeline() throws RecognitionException {
		PreprocessorParser.includeline_return retval = new PreprocessorParser.includeline_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token INCLUDE68=null;
		Token NEWLINE71=null;
		List<Object> list_t=null;
		ParserRuleReturnScope white69 =null;
		ParserRuleReturnScope white70 =null;
		RuleReturnScope t = null;
		Object INCLUDE68_tree=null;
		Object NEWLINE71_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_INCLUDE=new RewriteRuleTokenStream(adaptor,"token INCLUDE");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");
		RewriteRuleSubtreeStream stream_pptoken=new RewriteRuleSubtreeStream(adaptor,"rule pptoken");
		RewriteRuleSubtreeStream stream_wpptoken=new RewriteRuleSubtreeStream(adaptor,"rule wpptoken");

		try {
			// PreprocessorParser.g:240:13: ( INCLUDE ( white )* t+= pptoken ( (t+= wpptoken )* t+= pptoken )? ( white )* NEWLINE -> ^( INCLUDE ( $t)+ ) )
			// PreprocessorParser.g:240:15: INCLUDE ( white )* t+= pptoken ( (t+= wpptoken )* t+= pptoken )? ( white )* NEWLINE
			{
			INCLUDE68=(Token)match(input,INCLUDE,FOLLOW_INCLUDE_in_includeline1186); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_INCLUDE.add(INCLUDE68);

			// PreprocessorParser.g:240:23: ( white )*
			loop34:
			while (true) {
				int alt34=2;
				int LA34_0 = input.LA(1);
				if ( (LA34_0==COMMENT||LA34_0==WS) ) {
					alt34=1;
				}

				switch (alt34) {
				case 1 :
					// PreprocessorParser.g:240:23: white
					{
					pushFollow(FOLLOW_white_in_includeline1188);
					white69=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white69.getTree());
					}
					break;

				default :
					break loop34;
				}
			}

			pushFollow(FOLLOW_pptoken_in_includeline1193);
			t=pptoken();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_pptoken.add(t.getTree());
			if (list_t==null) list_t=new ArrayList<Object>();
			list_t.add(t.getTree());
			// PreprocessorParser.g:240:41: ( (t+= wpptoken )* t+= pptoken )?
			int alt36=2;
			alt36 = dfa36.predict(input);
			switch (alt36) {
				case 1 :
					// PreprocessorParser.g:240:42: (t+= wpptoken )* t+= pptoken
					{
					// PreprocessorParser.g:240:43: (t+= wpptoken )*
					loop35:
					while (true) {
						int alt35=2;
						alt35 = dfa35.predict(input);
						switch (alt35) {
						case 1 :
							// PreprocessorParser.g:240:43: t+= wpptoken
							{
							pushFollow(FOLLOW_wpptoken_in_includeline1198);
							t=wpptoken();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_wpptoken.add(t.getTree());
							if (list_t==null) list_t=new ArrayList<Object>();
							list_t.add(t.getTree());
							}
							break;

						default :
							break loop35;
						}
					}

					pushFollow(FOLLOW_pptoken_in_includeline1203);
					t=pptoken();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_pptoken.add(t.getTree());
					if (list_t==null) list_t=new ArrayList<Object>();
					list_t.add(t.getTree());
					}
					break;

			}

			// PreprocessorParser.g:241:5: ( white )*
			loop37:
			while (true) {
				int alt37=2;
				int LA37_0 = input.LA(1);
				if ( (LA37_0==COMMENT||LA37_0==WS) ) {
					alt37=1;
				}

				switch (alt37) {
				case 1 :
					// PreprocessorParser.g:241:5: white
					{
					pushFollow(FOLLOW_white_in_includeline1211);
					white70=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white70.getTree());
					}
					break;

				default :
					break loop37;
				}
			}

			NEWLINE71=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_includeline1214); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE71);

			// AST REWRITE
			// elements: t, INCLUDE
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: t
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
			RewriteRuleSubtreeStream stream_t=new RewriteRuleSubtreeStream(adaptor,"token t",list_t);
			root_0 = (Object)adaptor.nil();
			// 242:5: -> ^( INCLUDE ( $t)+ )
			{
				// PreprocessorParser.g:242:8: ^( INCLUDE ( $t)+ )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_INCLUDE.nextNode(), root_1);
				if ( !(stream_t.hasNext()) ) {
					throw new RewriteEarlyExitException();
				}
				while ( stream_t.hasNext() ) {
					adaptor.addChild(root_1, stream_t.nextTree());
				}
				stream_t.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "includeline"


	public static class pragmaline_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "pragmaline"
	// PreprocessorParser.g:245:1: pragmaline : PRAGMA ( wpptoken )* NEWLINE -> ^( PRAGMA ( wpptoken )* NEWLINE ) ;
	public final PreprocessorParser.pragmaline_return pragmaline() throws RecognitionException {
		PreprocessorParser.pragmaline_return retval = new PreprocessorParser.pragmaline_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token PRAGMA72=null;
		Token NEWLINE74=null;
		ParserRuleReturnScope wpptoken73 =null;

		Object PRAGMA72_tree=null;
		Object NEWLINE74_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_PRAGMA=new RewriteRuleTokenStream(adaptor,"token PRAGMA");
		RewriteRuleSubtreeStream stream_wpptoken=new RewriteRuleSubtreeStream(adaptor,"rule wpptoken");

		try {
			// PreprocessorParser.g:245:12: ( PRAGMA ( wpptoken )* NEWLINE -> ^( PRAGMA ( wpptoken )* NEWLINE ) )
			// PreprocessorParser.g:245:14: PRAGMA ( wpptoken )* NEWLINE
			{
			PRAGMA72=(Token)match(input,PRAGMA,FOLLOW_PRAGMA_in_pragmaline1239); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_PRAGMA.add(PRAGMA72);

			if ( state.backtracking==0 ) {PRAGMA72.setType(PPRAGMA);}
			// PreprocessorParser.g:245:48: ( wpptoken )*
			loop38:
			while (true) {
				int alt38=2;
				int LA38_0 = input.LA(1);
				if ( ((LA38_0 >= AMPERSAND && LA38_0 <= BITXOREQ)||(LA38_0 >= CHARACTER_CONSTANT && LA38_0 <= DOTDOT)||(LA38_0 >= ELIF && LA38_0 <= EXTENDED_IDENTIFIER)||LA38_0==FLOATING_CONSTANT||(LA38_0 >= GT && LA38_0 <= HASHHASH)||(LA38_0 >= IDENTIFIER && LA38_0 <= INLINE_ANNOTATION_START)||LA38_0==INTEGER_CONSTANT||(LA38_0 >= LCURLY && LA38_0 <= LTE)||(LA38_0 >= MINUSMINUS && LA38_0 <= NEQ)||LA38_0==NOT||(LA38_0 >= OR && LA38_0 <= OTHER)||(LA38_0 >= PLUS && LA38_0 <= RSQUARE)||(LA38_0 >= SEMI && LA38_0 <= UNDEF)||(LA38_0 >= WS && LA38_0 <= XOR_ACSL)) ) {
					alt38=1;
				}

				switch (alt38) {
				case 1 :
					// PreprocessorParser.g:245:48: wpptoken
					{
					pushFollow(FOLLOW_wpptoken_in_pragmaline1242);
					wpptoken73=wpptoken();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_wpptoken.add(wpptoken73.getTree());
					}
					break;

				default :
					break loop38;
				}
			}

			NEWLINE74=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_pragmaline1245); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE74);

			// AST REWRITE
			// elements: wpptoken, NEWLINE, PRAGMA
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 245:66: -> ^( PRAGMA ( wpptoken )* NEWLINE )
			{
				// PreprocessorParser.g:246:5: ^( PRAGMA ( wpptoken )* NEWLINE )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_PRAGMA.nextNode(), root_1);
				// PreprocessorParser.g:246:14: ( wpptoken )*
				while ( stream_wpptoken.hasNext() ) {
					adaptor.addChild(root_1, stream_wpptoken.nextTree());
				}
				stream_wpptoken.reset();

				adaptor.addChild(root_1, stream_NEWLINE.nextNode());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "pragmaline"


	public static class errorline_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "errorline"
	// PreprocessorParser.g:249:1: errorline : ERROR ( wpptoken )* NEWLINE -> ^( ERROR ( wpptoken )* ) ;
	public final PreprocessorParser.errorline_return errorline() throws RecognitionException {
		PreprocessorParser.errorline_return retval = new PreprocessorParser.errorline_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token ERROR75=null;
		Token NEWLINE77=null;
		ParserRuleReturnScope wpptoken76 =null;

		Object ERROR75_tree=null;
		Object NEWLINE77_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_ERROR=new RewriteRuleTokenStream(adaptor,"token ERROR");
		RewriteRuleSubtreeStream stream_wpptoken=new RewriteRuleSubtreeStream(adaptor,"rule wpptoken");

		try {
			// PreprocessorParser.g:249:11: ( ERROR ( wpptoken )* NEWLINE -> ^( ERROR ( wpptoken )* ) )
			// PreprocessorParser.g:249:13: ERROR ( wpptoken )* NEWLINE
			{
			ERROR75=(Token)match(input,ERROR,FOLLOW_ERROR_in_errorline1271); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_ERROR.add(ERROR75);

			// PreprocessorParser.g:249:19: ( wpptoken )*
			loop39:
			while (true) {
				int alt39=2;
				int LA39_0 = input.LA(1);
				if ( ((LA39_0 >= AMPERSAND && LA39_0 <= BITXOREQ)||(LA39_0 >= CHARACTER_CONSTANT && LA39_0 <= DOTDOT)||(LA39_0 >= ELIF && LA39_0 <= EXTENDED_IDENTIFIER)||LA39_0==FLOATING_CONSTANT||(LA39_0 >= GT && LA39_0 <= HASHHASH)||(LA39_0 >= IDENTIFIER && LA39_0 <= INLINE_ANNOTATION_START)||LA39_0==INTEGER_CONSTANT||(LA39_0 >= LCURLY && LA39_0 <= LTE)||(LA39_0 >= MINUSMINUS && LA39_0 <= NEQ)||LA39_0==NOT||(LA39_0 >= OR && LA39_0 <= OTHER)||(LA39_0 >= PLUS && LA39_0 <= RSQUARE)||(LA39_0 >= SEMI && LA39_0 <= UNDEF)||(LA39_0 >= WS && LA39_0 <= XOR_ACSL)) ) {
					alt39=1;
				}

				switch (alt39) {
				case 1 :
					// PreprocessorParser.g:249:19: wpptoken
					{
					pushFollow(FOLLOW_wpptoken_in_errorline1273);
					wpptoken76=wpptoken();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_wpptoken.add(wpptoken76.getTree());
					}
					break;

				default :
					break loop39;
				}
			}

			NEWLINE77=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_errorline1276); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE77);

			// AST REWRITE
			// elements: ERROR, wpptoken
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 249:37: -> ^( ERROR ( wpptoken )* )
			{
				// PreprocessorParser.g:249:40: ^( ERROR ( wpptoken )* )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_ERROR.nextNode(), root_1);
				// PreprocessorParser.g:249:48: ( wpptoken )*
				while ( stream_wpptoken.hasNext() ) {
					adaptor.addChild(root_1, stream_wpptoken.nextTree());
				}
				stream_wpptoken.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "errorline"


	public static class lineline_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "lineline"
	// PreprocessorParser.g:252:1: lineline : LINE ( wpptoken )* NEWLINE -> ^( LINE ( wpptoken )* ) ;
	public final PreprocessorParser.lineline_return lineline() throws RecognitionException {
		PreprocessorParser.lineline_return retval = new PreprocessorParser.lineline_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token LINE78=null;
		Token NEWLINE80=null;
		ParserRuleReturnScope wpptoken79 =null;

		Object LINE78_tree=null;
		Object NEWLINE80_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_LINE=new RewriteRuleTokenStream(adaptor,"token LINE");
		RewriteRuleSubtreeStream stream_wpptoken=new RewriteRuleSubtreeStream(adaptor,"rule wpptoken");

		try {
			// PreprocessorParser.g:252:10: ( LINE ( wpptoken )* NEWLINE -> ^( LINE ( wpptoken )* ) )
			// PreprocessorParser.g:252:12: LINE ( wpptoken )* NEWLINE
			{
			LINE78=(Token)match(input,LINE,FOLLOW_LINE_in_lineline1296); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_LINE.add(LINE78);

			// PreprocessorParser.g:252:17: ( wpptoken )*
			loop40:
			while (true) {
				int alt40=2;
				int LA40_0 = input.LA(1);
				if ( ((LA40_0 >= AMPERSAND && LA40_0 <= BITXOREQ)||(LA40_0 >= CHARACTER_CONSTANT && LA40_0 <= DOTDOT)||(LA40_0 >= ELIF && LA40_0 <= EXTENDED_IDENTIFIER)||LA40_0==FLOATING_CONSTANT||(LA40_0 >= GT && LA40_0 <= HASHHASH)||(LA40_0 >= IDENTIFIER && LA40_0 <= INLINE_ANNOTATION_START)||LA40_0==INTEGER_CONSTANT||(LA40_0 >= LCURLY && LA40_0 <= LTE)||(LA40_0 >= MINUSMINUS && LA40_0 <= NEQ)||LA40_0==NOT||(LA40_0 >= OR && LA40_0 <= OTHER)||(LA40_0 >= PLUS && LA40_0 <= RSQUARE)||(LA40_0 >= SEMI && LA40_0 <= UNDEF)||(LA40_0 >= WS && LA40_0 <= XOR_ACSL)) ) {
					alt40=1;
				}

				switch (alt40) {
				case 1 :
					// PreprocessorParser.g:252:17: wpptoken
					{
					pushFollow(FOLLOW_wpptoken_in_lineline1298);
					wpptoken79=wpptoken();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_wpptoken.add(wpptoken79.getTree());
					}
					break;

				default :
					break loop40;
				}
			}

			NEWLINE80=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_lineline1301); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE80);

			// AST REWRITE
			// elements: LINE, wpptoken
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 252:35: -> ^( LINE ( wpptoken )* )
			{
				// PreprocessorParser.g:252:38: ^( LINE ( wpptoken )* )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_LINE.nextNode(), root_1);
				// PreprocessorParser.g:252:45: ( wpptoken )*
				while ( stream_wpptoken.hasNext() ) {
					adaptor.addChild(root_1, stream_wpptoken.nextTree());
				}
				stream_wpptoken.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "lineline"


	public static class ifdefblock_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "ifdefblock"
	// PreprocessorParser.g:260:1: ifdefblock : IFDEF ( white )* i= identifier ( white )* NEWLINE t= if_section f= if_suffix -> ^( IFDEF $i ^( SEQUENCE ( $t)? ) ( $f)? ) ;
	public final PreprocessorParser.ifdefblock_return ifdefblock() throws RecognitionException {
		PreprocessorParser.ifdefblock_return retval = new PreprocessorParser.ifdefblock_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token IFDEF81=null;
		Token NEWLINE84=null;
		ParserRuleReturnScope i =null;
		ParserRuleReturnScope t =null;
		ParserRuleReturnScope f =null;
		ParserRuleReturnScope white82 =null;
		ParserRuleReturnScope white83 =null;

		Object IFDEF81_tree=null;
		Object NEWLINE84_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_IFDEF=new RewriteRuleTokenStream(adaptor,"token IFDEF");
		RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
		RewriteRuleSubtreeStream stream_if_section=new RewriteRuleSubtreeStream(adaptor,"rule if_section");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");
		RewriteRuleSubtreeStream stream_if_suffix=new RewriteRuleSubtreeStream(adaptor,"rule if_suffix");

		try {
			// PreprocessorParser.g:260:12: ( IFDEF ( white )* i= identifier ( white )* NEWLINE t= if_section f= if_suffix -> ^( IFDEF $i ^( SEQUENCE ( $t)? ) ( $f)? ) )
			// PreprocessorParser.g:260:14: IFDEF ( white )* i= identifier ( white )* NEWLINE t= if_section f= if_suffix
			{
			IFDEF81=(Token)match(input,IFDEF,FOLLOW_IFDEF_in_ifdefblock1323); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_IFDEF.add(IFDEF81);

			// PreprocessorParser.g:260:20: ( white )*
			loop41:
			while (true) {
				int alt41=2;
				int LA41_0 = input.LA(1);
				if ( (LA41_0==COMMENT||LA41_0==WS) ) {
					alt41=1;
				}

				switch (alt41) {
				case 1 :
					// PreprocessorParser.g:260:20: white
					{
					pushFollow(FOLLOW_white_in_ifdefblock1325);
					white82=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white82.getTree());
					}
					break;

				default :
					break loop41;
				}
			}

			pushFollow(FOLLOW_identifier_in_ifdefblock1330);
			i=identifier();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_identifier.add(i.getTree());
			// PreprocessorParser.g:260:40: ( white )*
			loop42:
			while (true) {
				int alt42=2;
				int LA42_0 = input.LA(1);
				if ( (LA42_0==COMMENT||LA42_0==WS) ) {
					alt42=1;
				}

				switch (alt42) {
				case 1 :
					// PreprocessorParser.g:260:40: white
					{
					pushFollow(FOLLOW_white_in_ifdefblock1332);
					white83=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white83.getTree());
					}
					break;

				default :
					break loop42;
				}
			}

			NEWLINE84=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_ifdefblock1335); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE84);

			pushFollow(FOLLOW_if_section_in_ifdefblock1343);
			t=if_section();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_if_section.add(t.getTree());
			pushFollow(FOLLOW_if_suffix_in_ifdefblock1347);
			f=if_suffix();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_if_suffix.add(f.getTree());
			// AST REWRITE
			// elements: IFDEF, f, t, i
			// token labels: 
			// rule labels: t, f, i, retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_t=new RewriteRuleSubtreeStream(adaptor,"rule t",t!=null?t.getTree():null);
			RewriteRuleSubtreeStream stream_f=new RewriteRuleSubtreeStream(adaptor,"rule f",f!=null?f.getTree():null);
			RewriteRuleSubtreeStream stream_i=new RewriteRuleSubtreeStream(adaptor,"rule i",i!=null?i.getTree():null);
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 262:5: -> ^( IFDEF $i ^( SEQUENCE ( $t)? ) ( $f)? )
			{
				// PreprocessorParser.g:262:8: ^( IFDEF $i ^( SEQUENCE ( $t)? ) ( $f)? )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_IFDEF.nextNode(), root_1);
				adaptor.addChild(root_1, stream_i.nextTree());
				// PreprocessorParser.g:262:19: ^( SEQUENCE ( $t)? )
				{
				Object root_2 = (Object)adaptor.nil();
				root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(SEQUENCE, "SEQUENCE"), root_2);
				// PreprocessorParser.g:262:31: ( $t)?
				if ( stream_t.hasNext() ) {
					adaptor.addChild(root_2, stream_t.nextTree());
				}
				stream_t.reset();

				adaptor.addChild(root_1, root_2);
				}

				// PreprocessorParser.g:262:36: ( $f)?
				if ( stream_f.hasNext() ) {
					adaptor.addChild(root_1, stream_f.nextTree());
				}
				stream_f.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ifdefblock"


	public static class ifndefblock_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "ifndefblock"
	// PreprocessorParser.g:266:1: ifndefblock : IFNDEF ( white )* i= identifier ( white )* NEWLINE t= if_section f= if_suffix -> ^( IFNDEF $i ^( SEQUENCE ( $t)? ) ( $f)? ) ;
	public final PreprocessorParser.ifndefblock_return ifndefblock() throws RecognitionException {
		PreprocessorParser.ifndefblock_return retval = new PreprocessorParser.ifndefblock_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token IFNDEF85=null;
		Token NEWLINE88=null;
		ParserRuleReturnScope i =null;
		ParserRuleReturnScope t =null;
		ParserRuleReturnScope f =null;
		ParserRuleReturnScope white86 =null;
		ParserRuleReturnScope white87 =null;

		Object IFNDEF85_tree=null;
		Object NEWLINE88_tree=null;
		RewriteRuleTokenStream stream_IFNDEF=new RewriteRuleTokenStream(adaptor,"token IFNDEF");
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleSubtreeStream stream_identifier=new RewriteRuleSubtreeStream(adaptor,"rule identifier");
		RewriteRuleSubtreeStream stream_if_section=new RewriteRuleSubtreeStream(adaptor,"rule if_section");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");
		RewriteRuleSubtreeStream stream_if_suffix=new RewriteRuleSubtreeStream(adaptor,"rule if_suffix");

		try {
			// PreprocessorParser.g:266:13: ( IFNDEF ( white )* i= identifier ( white )* NEWLINE t= if_section f= if_suffix -> ^( IFNDEF $i ^( SEQUENCE ( $t)? ) ( $f)? ) )
			// PreprocessorParser.g:266:15: IFNDEF ( white )* i= identifier ( white )* NEWLINE t= if_section f= if_suffix
			{
			IFNDEF85=(Token)match(input,IFNDEF,FOLLOW_IFNDEF_in_ifndefblock1385); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_IFNDEF.add(IFNDEF85);

			// PreprocessorParser.g:266:22: ( white )*
			loop43:
			while (true) {
				int alt43=2;
				int LA43_0 = input.LA(1);
				if ( (LA43_0==COMMENT||LA43_0==WS) ) {
					alt43=1;
				}

				switch (alt43) {
				case 1 :
					// PreprocessorParser.g:266:22: white
					{
					pushFollow(FOLLOW_white_in_ifndefblock1387);
					white86=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white86.getTree());
					}
					break;

				default :
					break loop43;
				}
			}

			pushFollow(FOLLOW_identifier_in_ifndefblock1392);
			i=identifier();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_identifier.add(i.getTree());
			// PreprocessorParser.g:266:42: ( white )*
			loop44:
			while (true) {
				int alt44=2;
				int LA44_0 = input.LA(1);
				if ( (LA44_0==COMMENT||LA44_0==WS) ) {
					alt44=1;
				}

				switch (alt44) {
				case 1 :
					// PreprocessorParser.g:266:42: white
					{
					pushFollow(FOLLOW_white_in_ifndefblock1394);
					white87=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white87.getTree());
					}
					break;

				default :
					break loop44;
				}
			}

			NEWLINE88=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_ifndefblock1397); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE88);

			pushFollow(FOLLOW_if_section_in_ifndefblock1405);
			t=if_section();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_if_section.add(t.getTree());
			pushFollow(FOLLOW_if_suffix_in_ifndefblock1409);
			f=if_suffix();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_if_suffix.add(f.getTree());
			// AST REWRITE
			// elements: i, IFNDEF, f, t
			// token labels: 
			// rule labels: t, f, i, retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_t=new RewriteRuleSubtreeStream(adaptor,"rule t",t!=null?t.getTree():null);
			RewriteRuleSubtreeStream stream_f=new RewriteRuleSubtreeStream(adaptor,"rule f",f!=null?f.getTree():null);
			RewriteRuleSubtreeStream stream_i=new RewriteRuleSubtreeStream(adaptor,"rule i",i!=null?i.getTree():null);
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 268:5: -> ^( IFNDEF $i ^( SEQUENCE ( $t)? ) ( $f)? )
			{
				// PreprocessorParser.g:268:8: ^( IFNDEF $i ^( SEQUENCE ( $t)? ) ( $f)? )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_IFNDEF.nextNode(), root_1);
				adaptor.addChild(root_1, stream_i.nextTree());
				// PreprocessorParser.g:268:20: ^( SEQUENCE ( $t)? )
				{
				Object root_2 = (Object)adaptor.nil();
				root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(SEQUENCE, "SEQUENCE"), root_2);
				// PreprocessorParser.g:268:32: ( $t)?
				if ( stream_t.hasNext() ) {
					adaptor.addChild(root_2, stream_t.nextTree());
				}
				stream_t.reset();

				adaptor.addChild(root_1, root_2);
				}

				// PreprocessorParser.g:268:37: ( $f)?
				if ( stream_f.hasNext() ) {
					adaptor.addChild(root_1, stream_f.nextTree());
				}
				stream_f.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ifndefblock"


	public static class ifblock_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "ifblock"
	// PreprocessorParser.g:274:1: ifblock : IF ( white )* e= expr ( white )* NEWLINE t= if_section f= if_suffix -> ^( IF $e ^( SEQUENCE ( $t)? ) ( $f)? ) ;
	public final PreprocessorParser.ifblock_return ifblock() throws RecognitionException {
		PreprocessorParser.ifblock_return retval = new PreprocessorParser.ifblock_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token IF89=null;
		Token NEWLINE92=null;
		ParserRuleReturnScope e =null;
		ParserRuleReturnScope t =null;
		ParserRuleReturnScope f =null;
		ParserRuleReturnScope white90 =null;
		ParserRuleReturnScope white91 =null;

		Object IF89_tree=null;
		Object NEWLINE92_tree=null;
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
		RewriteRuleSubtreeStream stream_if_section=new RewriteRuleSubtreeStream(adaptor,"rule if_section");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");
		RewriteRuleSubtreeStream stream_if_suffix=new RewriteRuleSubtreeStream(adaptor,"rule if_suffix");
		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");

		try {
			// PreprocessorParser.g:274:10: ( IF ( white )* e= expr ( white )* NEWLINE t= if_section f= if_suffix -> ^( IF $e ^( SEQUENCE ( $t)? ) ( $f)? ) )
			// PreprocessorParser.g:274:12: IF ( white )* e= expr ( white )* NEWLINE t= if_section f= if_suffix
			{
			IF89=(Token)match(input,IF,FOLLOW_IF_in_ifblock1448); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_IF.add(IF89);

			if ( state.backtracking==0 ) {IF89.setType(PIF);}
			// PreprocessorParser.g:275:5: ( white )*
			loop45:
			while (true) {
				int alt45=2;
				int LA45_0 = input.LA(1);
				if ( (LA45_0==COMMENT||LA45_0==WS) ) {
					alt45=1;
				}

				switch (alt45) {
				case 1 :
					// PreprocessorParser.g:275:5: white
					{
					pushFollow(FOLLOW_white_in_ifblock1455);
					white90=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white90.getTree());
					}
					break;

				default :
					break loop45;
				}
			}

			pushFollow(FOLLOW_expr_in_ifblock1460);
			e=expr();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_expr.add(e.getTree());
			// PreprocessorParser.g:275:19: ( white )*
			loop46:
			while (true) {
				int alt46=2;
				int LA46_0 = input.LA(1);
				if ( (LA46_0==COMMENT||LA46_0==WS) ) {
					alt46=1;
				}

				switch (alt46) {
				case 1 :
					// PreprocessorParser.g:275:19: white
					{
					pushFollow(FOLLOW_white_in_ifblock1462);
					white91=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_white.add(white91.getTree());
					}
					break;

				default :
					break loop46;
				}
			}

			NEWLINE92=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_ifblock1465); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE92);

			pushFollow(FOLLOW_if_section_in_ifblock1473);
			t=if_section();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_if_section.add(t.getTree());
			pushFollow(FOLLOW_if_suffix_in_ifblock1477);
			f=if_suffix();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_if_suffix.add(f.getTree());
			// AST REWRITE
			// elements: IF, t, f, e
			// token labels: 
			// rule labels: t, e, f, retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_t=new RewriteRuleSubtreeStream(adaptor,"rule t",t!=null?t.getTree():null);
			RewriteRuleSubtreeStream stream_e=new RewriteRuleSubtreeStream(adaptor,"rule e",e!=null?e.getTree():null);
			RewriteRuleSubtreeStream stream_f=new RewriteRuleSubtreeStream(adaptor,"rule f",f!=null?f.getTree():null);
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 277:5: -> ^( IF $e ^( SEQUENCE ( $t)? ) ( $f)? )
			{
				// PreprocessorParser.g:277:8: ^( IF $e ^( SEQUENCE ( $t)? ) ( $f)? )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot(stream_IF.nextNode(), root_1);
				adaptor.addChild(root_1, stream_e.nextTree());
				// PreprocessorParser.g:277:16: ^( SEQUENCE ( $t)? )
				{
				Object root_2 = (Object)adaptor.nil();
				root_2 = (Object)adaptor.becomeRoot((Object)adaptor.create(SEQUENCE, "SEQUENCE"), root_2);
				// PreprocessorParser.g:277:28: ( $t)?
				if ( stream_t.hasNext() ) {
					adaptor.addChild(root_2, stream_t.nextTree());
				}
				stream_t.reset();

				adaptor.addChild(root_1, root_2);
				}

				// PreprocessorParser.g:277:33: ( $f)?
				if ( stream_f.hasNext() ) {
					adaptor.addChild(root_1, stream_f.nextTree());
				}
				stream_f.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ifblock"


	public static class if_section_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "if_section"
	// PreprocessorParser.g:288:1: if_section : ( whiteBlock )? section_body ;
	public final PreprocessorParser.if_section_return if_section() throws RecognitionException {
		PreprocessorParser.if_section_return retval = new PreprocessorParser.if_section_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope whiteBlock93 =null;
		ParserRuleReturnScope section_body94 =null;


		try {
			// PreprocessorParser.g:288:12: ( ( whiteBlock )? section_body )
			// PreprocessorParser.g:288:14: ( whiteBlock )? section_body
			{
			root_0 = (Object)adaptor.nil();


			// PreprocessorParser.g:288:14: ( whiteBlock )?
			int alt47=2;
			int LA47_0 = input.LA(1);
			if ( (LA47_0==COMMENT||LA47_0==WS) ) {
				alt47=1;
			}
			switch (alt47) {
				case 1 :
					// PreprocessorParser.g:288:14: whiteBlock
					{
					pushFollow(FOLLOW_whiteBlock_in_if_section1516);
					whiteBlock93=whiteBlock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, whiteBlock93.getTree());

					}
					break;

			}

			pushFollow(FOLLOW_section_body_in_if_section1519);
			section_body94=section_body();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, section_body94.getTree());

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "if_section"


	public static class section_body_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "section_body"
	// PreprocessorParser.g:298:1: section_body : ( textBlock )? subsection ;
	public final PreprocessorParser.section_body_return section_body() throws RecognitionException {
		PreprocessorParser.section_body_return retval = new PreprocessorParser.section_body_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope textBlock95 =null;
		ParserRuleReturnScope subsection96 =null;


		try {
			// PreprocessorParser.g:298:14: ( ( textBlock )? subsection )
			// PreprocessorParser.g:298:16: ( textBlock )? subsection
			{
			root_0 = (Object)adaptor.nil();


			// PreprocessorParser.g:298:16: ( textBlock )?
			int alt48=2;
			int LA48_0 = input.LA(1);
			if ( ((LA48_0 >= AMPERSAND && LA48_0 <= COMMA)||(LA48_0 >= DEFINE && LA48_0 <= GTE)||(LA48_0 >= HASHHASH && LA48_0 <= UnsignedSuffix)||(LA48_0 >= XOR_ACSL && LA48_0 <= WITH)) ) {
				alt48=1;
			}
			switch (alt48) {
				case 1 :
					// PreprocessorParser.g:298:16: textBlock
					{
					pushFollow(FOLLOW_textBlock_in_section_body1532);
					textBlock95=textBlock();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, textBlock95.getTree());

					}
					break;

			}

			pushFollow(FOLLOW_subsection_in_section_body1535);
			subsection96=subsection();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, subsection96.getTree());

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "section_body"


	public static class subsection_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "subsection"
	// PreprocessorParser.g:307:1: subsection : HASH ! ( white !)* ( directiveSuffix ( whiteBlock )? section_body )? ;
	public final PreprocessorParser.subsection_return subsection() throws RecognitionException {
		PreprocessorParser.subsection_return retval = new PreprocessorParser.subsection_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token HASH97=null;
		ParserRuleReturnScope white98 =null;
		ParserRuleReturnScope directiveSuffix99 =null;
		ParserRuleReturnScope whiteBlock100 =null;
		ParserRuleReturnScope section_body101 =null;

		Object HASH97_tree=null;

		try {
			// PreprocessorParser.g:307:12: ( HASH ! ( white !)* ( directiveSuffix ( whiteBlock )? section_body )? )
			// PreprocessorParser.g:307:14: HASH ! ( white !)* ( directiveSuffix ( whiteBlock )? section_body )?
			{
			root_0 = (Object)adaptor.nil();


			HASH97=(Token)match(input,HASH,FOLLOW_HASH_in_subsection1548); if (state.failed) return retval;
			// PreprocessorParser.g:307:25: ( white !)*
			loop49:
			while (true) {
				int alt49=2;
				int LA49_0 = input.LA(1);
				if ( (LA49_0==COMMENT||LA49_0==WS) ) {
					alt49=1;
				}

				switch (alt49) {
				case 1 :
					// PreprocessorParser.g:307:25: white !
					{
					pushFollow(FOLLOW_white_in_subsection1551);
					white98=white();
					state._fsp--;
					if (state.failed) return retval;
					}
					break;

				default :
					break loop49;
				}
			}

			// PreprocessorParser.g:308:5: ( directiveSuffix ( whiteBlock )? section_body )?
			int alt51=2;
			int LA51_0 = input.LA(1);
			if ( ((LA51_0 >= AMPERSAND && LA51_0 <= BITXOREQ)||(LA51_0 >= CHARACTER_CONSTANT && LA51_0 <= COMMA)||LA51_0==DEFINE||(LA51_0 >= DIV && LA51_0 <= DOTDOT)||LA51_0==ELLIPSIS||(LA51_0 >= EQUALS && LA51_0 <= EXTENDED_IDENTIFIER)||LA51_0==FLOATING_CONSTANT||(LA51_0 >= GT && LA51_0 <= HASHHASH)||(LA51_0 >= IDENTIFIER && LA51_0 <= INLINE_ANNOTATION_START)||LA51_0==INTEGER_CONSTANT||(LA51_0 >= LCURLY && LA51_0 <= LTE)||(LA51_0 >= MINUSMINUS && LA51_0 <= NOT)||(LA51_0 >= OR && LA51_0 <= OTHER)||(LA51_0 >= PLUS && LA51_0 <= RSQUARE)||(LA51_0 >= SEMI && LA51_0 <= UNDEF)||LA51_0==XOR_ACSL) ) {
				alt51=1;
			}
			switch (alt51) {
				case 1 :
					// PreprocessorParser.g:308:7: directiveSuffix ( whiteBlock )? section_body
					{
					pushFollow(FOLLOW_directiveSuffix_in_subsection1561);
					directiveSuffix99=directiveSuffix();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, directiveSuffix99.getTree());

					// PreprocessorParser.g:308:23: ( whiteBlock )?
					int alt50=2;
					int LA50_0 = input.LA(1);
					if ( (LA50_0==COMMENT||LA50_0==WS) ) {
						alt50=1;
					}
					switch (alt50) {
						case 1 :
							// PreprocessorParser.g:308:23: whiteBlock
							{
							pushFollow(FOLLOW_whiteBlock_in_subsection1563);
							whiteBlock100=whiteBlock();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) adaptor.addChild(root_0, whiteBlock100.getTree());

							}
							break;

					}

					pushFollow(FOLLOW_section_body_in_subsection1566);
					section_body101=section_body();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, section_body101.getTree());

					}
					break;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "subsection"


	public static class if_suffix_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "if_suffix"
	// PreprocessorParser.g:322:1: if_suffix : ( ENDIF ( white )* NEWLINE ->|c= ELIF ( white )* expr ( white )* NEWLINE if_section if_suffix -> ^( $c ^( $c expr ^( SEQUENCE ( if_section )? ) ( if_suffix )? ) ) | ELSE ( white )* NEWLINE if_section ENDIF ( white )* NEWLINE -> ^( ELSE ( if_section )? ) );
	public final PreprocessorParser.if_suffix_return if_suffix() throws RecognitionException {
		PreprocessorParser.if_suffix_return retval = new PreprocessorParser.if_suffix_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token c=null;
		Token ENDIF102=null;
		Token NEWLINE104=null;
		Token NEWLINE108=null;
		Token ELSE111=null;
		Token NEWLINE113=null;
		Token ENDIF115=null;
		Token NEWLINE117=null;
		ParserRuleReturnScope white103 =null;
		ParserRuleReturnScope white105 =null;
		ParserRuleReturnScope expr106 =null;
		ParserRuleReturnScope white107 =null;
		ParserRuleReturnScope if_section109 =null;
		ParserRuleReturnScope if_suffix110 =null;
		ParserRuleReturnScope white112 =null;
		ParserRuleReturnScope if_section114 =null;
		ParserRuleReturnScope white116 =null;

		Object c_tree=null;
		Object ENDIF102_tree=null;
		Object NEWLINE104_tree=null;
		Object NEWLINE108_tree=null;
		Object ELSE111_tree=null;
		Object NEWLINE113_tree=null;
		Object ENDIF115_tree=null;
		Object NEWLINE117_tree=null;
		RewriteRuleTokenStream stream_ELIF=new RewriteRuleTokenStream(adaptor,"token ELIF");
		RewriteRuleTokenStream stream_NEWLINE=new RewriteRuleTokenStream(adaptor,"token NEWLINE");
		RewriteRuleTokenStream stream_ENDIF=new RewriteRuleTokenStream(adaptor,"token ENDIF");
		RewriteRuleTokenStream stream_ELSE=new RewriteRuleTokenStream(adaptor,"token ELSE");
		RewriteRuleSubtreeStream stream_if_section=new RewriteRuleSubtreeStream(adaptor,"rule if_section");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");
		RewriteRuleSubtreeStream stream_if_suffix=new RewriteRuleSubtreeStream(adaptor,"rule if_suffix");
		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");

		try {
			// PreprocessorParser.g:322:11: ( ENDIF ( white )* NEWLINE ->|c= ELIF ( white )* expr ( white )* NEWLINE if_section if_suffix -> ^( $c ^( $c expr ^( SEQUENCE ( if_section )? ) ( if_suffix )? ) ) | ELSE ( white )* NEWLINE if_section ENDIF ( white )* NEWLINE -> ^( ELSE ( if_section )? ) )
			int alt57=3;
			switch ( input.LA(1) ) {
			case ENDIF:
				{
				alt57=1;
				}
				break;
			case ELIF:
				{
				alt57=2;
				}
				break;
			case ELSE:
				{
				alt57=3;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 57, 0, input);
				throw nvae;
			}
			switch (alt57) {
				case 1 :
					// PreprocessorParser.g:322:13: ENDIF ( white )* NEWLINE
					{
					ENDIF102=(Token)match(input,ENDIF,FOLLOW_ENDIF_in_if_suffix1581); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_ENDIF.add(ENDIF102);

					// PreprocessorParser.g:322:19: ( white )*
					loop52:
					while (true) {
						int alt52=2;
						int LA52_0 = input.LA(1);
						if ( (LA52_0==COMMENT||LA52_0==WS) ) {
							alt52=1;
						}

						switch (alt52) {
						case 1 :
							// PreprocessorParser.g:322:19: white
							{
							pushFollow(FOLLOW_white_in_if_suffix1583);
							white103=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white103.getTree());
							}
							break;

						default :
							break loop52;
						}
					}

					NEWLINE104=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_if_suffix1586); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE104);

					// AST REWRITE
					// elements: 
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 323:6: ->
					{
						root_0 = null;
					}


					retval.tree = root_0;
					}

					}
					break;
				case 2 :
					// PreprocessorParser.g:324:5: c= ELIF ( white )* expr ( white )* NEWLINE if_section if_suffix
					{
					c=(Token)match(input,ELIF,FOLLOW_ELIF_in_if_suffix1602); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_ELIF.add(c);

					// PreprocessorParser.g:324:12: ( white )*
					loop53:
					while (true) {
						int alt53=2;
						int LA53_0 = input.LA(1);
						if ( (LA53_0==COMMENT||LA53_0==WS) ) {
							alt53=1;
						}

						switch (alt53) {
						case 1 :
							// PreprocessorParser.g:324:12: white
							{
							pushFollow(FOLLOW_white_in_if_suffix1604);
							white105=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white105.getTree());
							}
							break;

						default :
							break loop53;
						}
					}

					pushFollow(FOLLOW_expr_in_if_suffix1607);
					expr106=expr();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr.add(expr106.getTree());
					// PreprocessorParser.g:324:24: ( white )*
					loop54:
					while (true) {
						int alt54=2;
						int LA54_0 = input.LA(1);
						if ( (LA54_0==COMMENT||LA54_0==WS) ) {
							alt54=1;
						}

						switch (alt54) {
						case 1 :
							// PreprocessorParser.g:324:24: white
							{
							pushFollow(FOLLOW_white_in_if_suffix1609);
							white107=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white107.getTree());
							}
							break;

						default :
							break loop54;
						}
					}

					NEWLINE108=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_if_suffix1612); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE108);

					pushFollow(FOLLOW_if_section_in_if_suffix1614);
					if_section109=if_section();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_if_section.add(if_section109.getTree());
					pushFollow(FOLLOW_if_suffix_in_if_suffix1616);
					if_suffix110=if_suffix();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_if_suffix.add(if_suffix110.getTree());
					// AST REWRITE
					// elements: if_section, expr, c, c, if_suffix
					// token labels: c
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleTokenStream stream_c=new RewriteRuleTokenStream(adaptor,"token c",c);
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 325:5: -> ^( $c ^( $c expr ^( SEQUENCE ( if_section )? ) ( if_suffix )? ) )
					{
						// PreprocessorParser.g:325:8: ^( $c ^( $c expr ^( SEQUENCE ( if_section )? ) ( if_suffix )? ) )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_c.nextNode(), root_1);
						// PreprocessorParser.g:325:13: ^( $c expr ^( SEQUENCE ( if_section )? ) ( if_suffix )? )
						{
						Object root_2 = (Object)adaptor.nil();
						root_2 = (Object)adaptor.becomeRoot(stream_c.nextNode(), root_2);
						adaptor.addChild(root_2, stream_expr.nextTree());
						// PreprocessorParser.g:325:23: ^( SEQUENCE ( if_section )? )
						{
						Object root_3 = (Object)adaptor.nil();
						root_3 = (Object)adaptor.becomeRoot((Object)adaptor.create(SEQUENCE, "SEQUENCE"), root_3);
						// PreprocessorParser.g:325:34: ( if_section )?
						if ( stream_if_section.hasNext() ) {
							adaptor.addChild(root_3, stream_if_section.nextTree());
						}
						stream_if_section.reset();

						adaptor.addChild(root_2, root_3);
						}

						// PreprocessorParser.g:325:47: ( if_suffix )?
						if ( stream_if_suffix.hasNext() ) {
							adaptor.addChild(root_2, stream_if_suffix.nextTree());
						}
						stream_if_suffix.reset();

						adaptor.addChild(root_1, root_2);
						}

						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 3 :
					// PreprocessorParser.g:326:5: ELSE ( white )* NEWLINE if_section ENDIF ( white )* NEWLINE
					{
					ELSE111=(Token)match(input,ELSE,FOLLOW_ELSE_in_if_suffix1650); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_ELSE.add(ELSE111);

					if ( state.backtracking==0 ) {ELSE111.setType(PELSE);}
					// PreprocessorParser.g:327:5: ( white )*
					loop55:
					while (true) {
						int alt55=2;
						int LA55_0 = input.LA(1);
						if ( (LA55_0==COMMENT||LA55_0==WS) ) {
							alt55=1;
						}

						switch (alt55) {
						case 1 :
							// PreprocessorParser.g:327:5: white
							{
							pushFollow(FOLLOW_white_in_if_suffix1657);
							white112=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white112.getTree());
							}
							break;

						default :
							break loop55;
						}
					}

					NEWLINE113=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_if_suffix1660); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE113);

					pushFollow(FOLLOW_if_section_in_if_suffix1662);
					if_section114=if_section();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_if_section.add(if_section114.getTree());
					ENDIF115=(Token)match(input,ENDIF,FOLLOW_ENDIF_in_if_suffix1664); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_ENDIF.add(ENDIF115);

					// PreprocessorParser.g:327:37: ( white )*
					loop56:
					while (true) {
						int alt56=2;
						int LA56_0 = input.LA(1);
						if ( (LA56_0==COMMENT||LA56_0==WS) ) {
							alt56=1;
						}

						switch (alt56) {
						case 1 :
							// PreprocessorParser.g:327:37: white
							{
							pushFollow(FOLLOW_white_in_if_suffix1666);
							white116=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white116.getTree());
							}
							break;

						default :
							break loop56;
						}
					}

					NEWLINE117=(Token)match(input,NEWLINE,FOLLOW_NEWLINE_in_if_suffix1669); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_NEWLINE.add(NEWLINE117);

					// AST REWRITE
					// elements: ELSE, if_section
					// token labels: 
					// rule labels: retval
					// token list labels: 
					// rule list labels: 
					// wildcard labels: 
					if ( state.backtracking==0 ) {
					retval.tree = root_0;
					RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

					root_0 = (Object)adaptor.nil();
					// 328:5: -> ^( ELSE ( if_section )? )
					{
						// PreprocessorParser.g:328:8: ^( ELSE ( if_section )? )
						{
						Object root_1 = (Object)adaptor.nil();
						root_1 = (Object)adaptor.becomeRoot(stream_ELSE.nextNode(), root_1);
						// PreprocessorParser.g:328:15: ( if_section )?
						if ( stream_if_section.hasNext() ) {
							adaptor.addChild(root_1, stream_if_section.nextTree());
						}
						stream_if_section.reset();

						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "if_suffix"


	public static class white_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "white"
	// PreprocessorParser.g:332:1: white : ( WS | COMMENT );
	public final PreprocessorParser.white_return white() throws RecognitionException {
		PreprocessorParser.white_return retval = new PreprocessorParser.white_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set118=null;

		Object set118_tree=null;

		try {
			// PreprocessorParser.g:332:8: ( WS | COMMENT )
			// PreprocessorParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set118=input.LT(1);
			if ( input.LA(1)==COMMENT||input.LA(1)==WS ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set118));
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "white"


	public static class wpptoken_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "wpptoken"
	// PreprocessorParser.g:335:1: wpptoken : ( pptoken | white );
	public final PreprocessorParser.wpptoken_return wpptoken() throws RecognitionException {
		PreprocessorParser.wpptoken_return retval = new PreprocessorParser.wpptoken_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope pptoken119 =null;
		ParserRuleReturnScope white120 =null;


		try {
			// PreprocessorParser.g:335:10: ( pptoken | white )
			int alt58=2;
			int LA58_0 = input.LA(1);
			if ( ((LA58_0 >= AMPERSAND && LA58_0 <= BITXOREQ)||(LA58_0 >= CHARACTER_CONSTANT && LA58_0 <= COMMA)||(LA58_0 >= DEFINE && LA58_0 <= DOTDOT)||(LA58_0 >= ELIF && LA58_0 <= EXTENDED_IDENTIFIER)||LA58_0==FLOATING_CONSTANT||(LA58_0 >= GT && LA58_0 <= HASHHASH)||(LA58_0 >= IDENTIFIER && LA58_0 <= INLINE_ANNOTATION_START)||LA58_0==INTEGER_CONSTANT||(LA58_0 >= LCURLY && LA58_0 <= LTE)||(LA58_0 >= MINUSMINUS && LA58_0 <= NEQ)||LA58_0==NOT||(LA58_0 >= OR && LA58_0 <= OTHER)||(LA58_0 >= PLUS && LA58_0 <= RSQUARE)||(LA58_0 >= SEMI && LA58_0 <= UNDEF)||LA58_0==XOR_ACSL) ) {
				alt58=1;
			}
			else if ( (LA58_0==COMMENT||LA58_0==WS) ) {
				alt58=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 58, 0, input);
				throw nvae;
			}

			switch (alt58) {
				case 1 :
					// PreprocessorParser.g:335:12: pptoken
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_pptoken_in_wpptoken1711);
					pptoken119=pptoken();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, pptoken119.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:335:22: white
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_white_in_wpptoken1715);
					white120=white();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, white120.getTree());

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "wpptoken"


	public static class expr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "expr"
	// PreprocessorParser.g:339:1: expr : ppdExpr ( ( white )* ppdExpr )* -> ^( EXPR ( ppdExpr )+ ) ;
	public final PreprocessorParser.expr_return expr() throws RecognitionException {
		PreprocessorParser.expr_return retval = new PreprocessorParser.expr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope ppdExpr121 =null;
		ParserRuleReturnScope white122 =null;
		ParserRuleReturnScope ppdExpr123 =null;

		RewriteRuleSubtreeStream stream_ppdExpr=new RewriteRuleSubtreeStream(adaptor,"rule ppdExpr");
		RewriteRuleSubtreeStream stream_white=new RewriteRuleSubtreeStream(adaptor,"rule white");

		try {
			// PreprocessorParser.g:339:7: ( ppdExpr ( ( white )* ppdExpr )* -> ^( EXPR ( ppdExpr )+ ) )
			// PreprocessorParser.g:339:9: ppdExpr ( ( white )* ppdExpr )*
			{
			pushFollow(FOLLOW_ppdExpr_in_expr1727);
			ppdExpr121=ppdExpr();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_ppdExpr.add(ppdExpr121.getTree());
			// PreprocessorParser.g:339:17: ( ( white )* ppdExpr )*
			loop60:
			while (true) {
				int alt60=2;
				alt60 = dfa60.predict(input);
				switch (alt60) {
				case 1 :
					// PreprocessorParser.g:339:18: ( white )* ppdExpr
					{
					// PreprocessorParser.g:339:18: ( white )*
					loop59:
					while (true) {
						int alt59=2;
						int LA59_0 = input.LA(1);
						if ( (LA59_0==COMMENT||LA59_0==WS) ) {
							alt59=1;
						}

						switch (alt59) {
						case 1 :
							// PreprocessorParser.g:339:18: white
							{
							pushFollow(FOLLOW_white_in_expr1730);
							white122=white();
							state._fsp--;
							if (state.failed) return retval;
							if ( state.backtracking==0 ) stream_white.add(white122.getTree());
							}
							break;

						default :
							break loop59;
						}
					}

					pushFollow(FOLLOW_ppdExpr_in_expr1733);
					ppdExpr123=ppdExpr();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_ppdExpr.add(ppdExpr123.getTree());
					}
					break;

				default :
					break loop60;
				}
			}

			// AST REWRITE
			// elements: ppdExpr
			// token labels: 
			// rule labels: retval
			// token list labels: 
			// rule list labels: 
			// wildcard labels: 
			if ( state.backtracking==0 ) {
			retval.tree = root_0;
			RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);

			root_0 = (Object)adaptor.nil();
			// 339:35: -> ^( EXPR ( ppdExpr )+ )
			{
				// PreprocessorParser.g:339:38: ^( EXPR ( ppdExpr )+ )
				{
				Object root_1 = (Object)adaptor.nil();
				root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(EXPR, "EXPR"), root_1);
				if ( !(stream_ppdExpr.hasNext()) ) {
					throw new RewriteEarlyExitException();
				}
				while ( stream_ppdExpr.hasNext() ) {
					adaptor.addChild(root_1, stream_ppdExpr.nextTree());
				}
				stream_ppdExpr.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "expr"


	public static class definedExpr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "definedExpr"
	// PreprocessorParser.g:341:1: definedExpr : DEFINED ( white !)* ( identifier | LPAREN ! ( white !)* identifier ( white !)* RPAREN !) ;
	public final PreprocessorParser.definedExpr_return definedExpr() throws RecognitionException {
		PreprocessorParser.definedExpr_return retval = new PreprocessorParser.definedExpr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token DEFINED124=null;
		Token LPAREN127=null;
		Token RPAREN131=null;
		ParserRuleReturnScope white125 =null;
		ParserRuleReturnScope identifier126 =null;
		ParserRuleReturnScope white128 =null;
		ParserRuleReturnScope identifier129 =null;
		ParserRuleReturnScope white130 =null;

		Object DEFINED124_tree=null;
		Object LPAREN127_tree=null;
		Object RPAREN131_tree=null;

		try {
			// PreprocessorParser.g:341:13: ( DEFINED ( white !)* ( identifier | LPAREN ! ( white !)* identifier ( white !)* RPAREN !) )
			// PreprocessorParser.g:341:15: DEFINED ( white !)* ( identifier | LPAREN ! ( white !)* identifier ( white !)* RPAREN !)
			{
			root_0 = (Object)adaptor.nil();


			DEFINED124=(Token)match(input,DEFINED,FOLLOW_DEFINED_in_definedExpr1753); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			DEFINED124_tree = (Object)adaptor.create(DEFINED124);
			adaptor.addChild(root_0, DEFINED124_tree);
			}

			// PreprocessorParser.g:341:28: ( white !)*
			loop61:
			while (true) {
				int alt61=2;
				int LA61_0 = input.LA(1);
				if ( (LA61_0==COMMENT||LA61_0==WS) ) {
					alt61=1;
				}

				switch (alt61) {
				case 1 :
					// PreprocessorParser.g:341:28: white !
					{
					pushFollow(FOLLOW_white_in_definedExpr1755);
					white125=white();
					state._fsp--;
					if (state.failed) return retval;
					}
					break;

				default :
					break loop61;
				}
			}

			// PreprocessorParser.g:342:5: ( identifier | LPAREN ! ( white !)* identifier ( white !)* RPAREN !)
			int alt64=2;
			int LA64_0 = input.LA(1);
			if ( ((LA64_0 >= DEFINE && LA64_0 <= DEFINED)||LA64_0==ELIF||(LA64_0 >= ELSE && LA64_0 <= ENDIF)||(LA64_0 >= ERROR && LA64_0 <= EXTENDED_IDENTIFIER)||(LA64_0 >= IDENTIFIER && LA64_0 <= IFNDEF)||LA64_0==INCLUDE||LA64_0==LINE||LA64_0==PRAGMA||LA64_0==UNDEF) ) {
				alt64=1;
			}
			else if ( (LA64_0==LPAREN) ) {
				alt64=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 64, 0, input);
				throw nvae;
			}

			switch (alt64) {
				case 1 :
					// PreprocessorParser.g:342:7: identifier
					{
					pushFollow(FOLLOW_identifier_in_definedExpr1765);
					identifier126=identifier();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, identifier126.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:343:7: LPAREN ! ( white !)* identifier ( white !)* RPAREN !
					{
					LPAREN127=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_definedExpr1773); if (state.failed) return retval;
					// PreprocessorParser.g:343:20: ( white !)*
					loop62:
					while (true) {
						int alt62=2;
						int LA62_0 = input.LA(1);
						if ( (LA62_0==COMMENT||LA62_0==WS) ) {
							alt62=1;
						}

						switch (alt62) {
						case 1 :
							// PreprocessorParser.g:343:20: white !
							{
							pushFollow(FOLLOW_white_in_definedExpr1776);
							white128=white();
							state._fsp--;
							if (state.failed) return retval;
							}
							break;

						default :
							break loop62;
						}
					}

					pushFollow(FOLLOW_identifier_in_definedExpr1780);
					identifier129=identifier();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, identifier129.getTree());

					// PreprocessorParser.g:343:39: ( white !)*
					loop63:
					while (true) {
						int alt63=2;
						int LA63_0 = input.LA(1);
						if ( (LA63_0==COMMENT||LA63_0==WS) ) {
							alt63=1;
						}

						switch (alt63) {
						case 1 :
							// PreprocessorParser.g:343:39: white !
							{
							pushFollow(FOLLOW_white_in_definedExpr1782);
							white130=white();
							state._fsp--;
							if (state.failed) return retval;
							}
							break;

						default :
							break loop63;
						}
					}

					RPAREN131=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_definedExpr1786); if (state.failed) return retval;
					}
					break;

			}

			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "definedExpr"


	public static class ppdExpr_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "ppdExpr"
	// PreprocessorParser.g:349:1: ppdExpr : ( ( DEFINED )=> definedExpr | pptoken );
	public final PreprocessorParser.ppdExpr_return ppdExpr() throws RecognitionException {
		PreprocessorParser.ppdExpr_return retval = new PreprocessorParser.ppdExpr_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope definedExpr132 =null;
		ParserRuleReturnScope pptoken133 =null;


		try {
			// PreprocessorParser.g:349:10: ( ( DEFINED )=> definedExpr | pptoken )
			int alt65=2;
			alt65 = dfa65.predict(input);
			switch (alt65) {
				case 1 :
					// PreprocessorParser.g:349:12: ( DEFINED )=> definedExpr
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_definedExpr_in_ppdExpr1813);
					definedExpr132=definedExpr();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, definedExpr132.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:350:5: pptoken
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_pptoken_in_ppdExpr1819);
					pptoken133=pptoken();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, pptoken133.getTree());

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "ppdExpr"


	public static class pptoken_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "pptoken"
	// PreprocessorParser.g:357:1: pptoken : ( identifier | pp_number | CHARACTER_CONSTANT | STRING_LITERAL | punctuator | OTHER );
	public final PreprocessorParser.pptoken_return pptoken() throws RecognitionException {
		PreprocessorParser.pptoken_return retval = new PreprocessorParser.pptoken_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token CHARACTER_CONSTANT136=null;
		Token STRING_LITERAL137=null;
		Token OTHER139=null;
		ParserRuleReturnScope identifier134 =null;
		ParserRuleReturnScope pp_number135 =null;
		ParserRuleReturnScope punctuator138 =null;

		Object CHARACTER_CONSTANT136_tree=null;
		Object STRING_LITERAL137_tree=null;
		Object OTHER139_tree=null;

		try {
			// PreprocessorParser.g:357:10: ( identifier | pp_number | CHARACTER_CONSTANT | STRING_LITERAL | punctuator | OTHER )
			int alt66=6;
			switch ( input.LA(1) ) {
			case DEFINE:
			case DEFINED:
			case ELIF:
			case ELSE:
			case ENDIF:
			case ERROR:
			case EXTENDED_IDENTIFIER:
			case IDENTIFIER:
			case IF:
			case IFDEF:
			case IFNDEF:
			case INCLUDE:
			case LINE:
			case PRAGMA:
			case UNDEF:
				{
				alt66=1;
				}
				break;
			case FLOATING_CONSTANT:
			case INTEGER_CONSTANT:
			case PP_NUMBER:
				{
				alt66=2;
				}
				break;
			case CHARACTER_CONSTANT:
				{
				alt66=3;
				}
				break;
			case STRING_LITERAL:
				{
				alt66=4;
				}
				break;
			case AMPERSAND:
			case AND:
			case ANNOTATION_END:
			case ANNOTATION_START:
			case ARROW:
			case ASSIGN:
			case AT:
			case BITANDEQ:
			case BITOR:
			case BITOREQ:
			case BITXOR:
			case BITXOREQ:
			case COLON:
			case COMMA:
			case DIV:
			case DIVEQ:
			case DOT:
			case DOTDOT:
			case ELLIPSIS:
			case EQUALS:
			case EQUIV_ACSL:
			case GT:
			case GTE:
			case HASH:
			case HASHHASH:
			case IMPLIES:
			case IMPLIES_ACSL:
			case INLINE_ANNOTATION_START:
			case LCURLY:
			case LEXCON:
			case LPAREN:
			case LSLIST:
			case LSQUARE:
			case LT:
			case LTE:
			case MINUSMINUS:
			case MOD:
			case MODEQ:
			case NEQ:
			case NOT:
			case OR:
			case PLUS:
			case PLUSEQ:
			case PLUSPLUS:
			case QMARK:
			case RCURLY:
			case REXCON:
			case RPAREN:
			case RSLIST:
			case RSQUARE:
			case SEMI:
			case SHIFTLEFT:
			case SHIFTLEFTEQ:
			case SHIFTRIGHT:
			case SHIFTRIGHTEQ:
			case STAR:
			case STAREQ:
			case SUB:
			case SUBEQ:
			case TILDE:
			case XOR_ACSL:
				{
				alt66=5;
				}
				break;
			case OTHER:
				{
				alt66=6;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 66, 0, input);
				throw nvae;
			}
			switch (alt66) {
				case 1 :
					// PreprocessorParser.g:357:12: identifier
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_identifier_in_pptoken1833);
					identifier134=identifier();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, identifier134.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:358:5: pp_number
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_pp_number_in_pptoken1839);
					pp_number135=pp_number();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, pp_number135.getTree());

					}
					break;
				case 3 :
					// PreprocessorParser.g:359:5: CHARACTER_CONSTANT
					{
					root_0 = (Object)adaptor.nil();


					CHARACTER_CONSTANT136=(Token)match(input,CHARACTER_CONSTANT,FOLLOW_CHARACTER_CONSTANT_in_pptoken1845); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					CHARACTER_CONSTANT136_tree = (Object)adaptor.create(CHARACTER_CONSTANT136);
					adaptor.addChild(root_0, CHARACTER_CONSTANT136_tree);
					}

					}
					break;
				case 4 :
					// PreprocessorParser.g:360:5: STRING_LITERAL
					{
					root_0 = (Object)adaptor.nil();


					STRING_LITERAL137=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_pptoken1851); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					STRING_LITERAL137_tree = (Object)adaptor.create(STRING_LITERAL137);
					adaptor.addChild(root_0, STRING_LITERAL137_tree);
					}

					}
					break;
				case 5 :
					// PreprocessorParser.g:361:5: punctuator
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_punctuator_in_pptoken1857);
					punctuator138=punctuator();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, punctuator138.getTree());

					}
					break;
				case 6 :
					// PreprocessorParser.g:362:5: OTHER
					{
					root_0 = (Object)adaptor.nil();


					OTHER139=(Token)match(input,OTHER,FOLLOW_OTHER_in_pptoken1863); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					OTHER139_tree = (Object)adaptor.create(OTHER139);
					adaptor.addChild(root_0, OTHER139_tree);
					}

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "pptoken"


	public static class not_directive_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "not_directive"
	// PreprocessorParser.g:366:1: not_directive : ( pp_number | CHARACTER_CONSTANT | STRING_LITERAL | punctuator | OTHER | IDENTIFIER | EXTENDED_IDENTIFIER );
	public final PreprocessorParser.not_directive_return not_directive() throws RecognitionException {
		PreprocessorParser.not_directive_return retval = new PreprocessorParser.not_directive_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token CHARACTER_CONSTANT141=null;
		Token STRING_LITERAL142=null;
		Token OTHER144=null;
		Token IDENTIFIER145=null;
		Token EXTENDED_IDENTIFIER146=null;
		ParserRuleReturnScope pp_number140 =null;
		ParserRuleReturnScope punctuator143 =null;

		Object CHARACTER_CONSTANT141_tree=null;
		Object STRING_LITERAL142_tree=null;
		Object OTHER144_tree=null;
		Object IDENTIFIER145_tree=null;
		Object EXTENDED_IDENTIFIER146_tree=null;

		try {
			// PreprocessorParser.g:366:15: ( pp_number | CHARACTER_CONSTANT | STRING_LITERAL | punctuator | OTHER | IDENTIFIER | EXTENDED_IDENTIFIER )
			int alt67=7;
			switch ( input.LA(1) ) {
			case FLOATING_CONSTANT:
			case INTEGER_CONSTANT:
			case PP_NUMBER:
				{
				alt67=1;
				}
				break;
			case CHARACTER_CONSTANT:
				{
				alt67=2;
				}
				break;
			case STRING_LITERAL:
				{
				alt67=3;
				}
				break;
			case AMPERSAND:
			case AND:
			case ANNOTATION_END:
			case ANNOTATION_START:
			case ARROW:
			case ASSIGN:
			case AT:
			case BITANDEQ:
			case BITOR:
			case BITOREQ:
			case BITXOR:
			case BITXOREQ:
			case COLON:
			case COMMA:
			case DIV:
			case DIVEQ:
			case DOT:
			case DOTDOT:
			case ELLIPSIS:
			case EQUALS:
			case EQUIV_ACSL:
			case GT:
			case GTE:
			case HASH:
			case HASHHASH:
			case IMPLIES:
			case IMPLIES_ACSL:
			case INLINE_ANNOTATION_START:
			case LCURLY:
			case LEXCON:
			case LPAREN:
			case LSLIST:
			case LSQUARE:
			case LT:
			case LTE:
			case MINUSMINUS:
			case MOD:
			case MODEQ:
			case NEQ:
			case NOT:
			case OR:
			case PLUS:
			case PLUSEQ:
			case PLUSPLUS:
			case QMARK:
			case RCURLY:
			case REXCON:
			case RPAREN:
			case RSLIST:
			case RSQUARE:
			case SEMI:
			case SHIFTLEFT:
			case SHIFTLEFTEQ:
			case SHIFTRIGHT:
			case SHIFTRIGHTEQ:
			case STAR:
			case STAREQ:
			case SUB:
			case SUBEQ:
			case TILDE:
			case XOR_ACSL:
				{
				alt67=4;
				}
				break;
			case OTHER:
				{
				alt67=5;
				}
				break;
			case IDENTIFIER:
				{
				alt67=6;
				}
				break;
			case EXTENDED_IDENTIFIER:
				{
				alt67=7;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 67, 0, input);
				throw nvae;
			}
			switch (alt67) {
				case 1 :
					// PreprocessorParser.g:366:17: pp_number
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_pp_number_in_not_directive1876);
					pp_number140=pp_number();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, pp_number140.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:367:5: CHARACTER_CONSTANT
					{
					root_0 = (Object)adaptor.nil();


					CHARACTER_CONSTANT141=(Token)match(input,CHARACTER_CONSTANT,FOLLOW_CHARACTER_CONSTANT_in_not_directive1882); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					CHARACTER_CONSTANT141_tree = (Object)adaptor.create(CHARACTER_CONSTANT141);
					adaptor.addChild(root_0, CHARACTER_CONSTANT141_tree);
					}

					}
					break;
				case 3 :
					// PreprocessorParser.g:368:5: STRING_LITERAL
					{
					root_0 = (Object)adaptor.nil();


					STRING_LITERAL142=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_not_directive1888); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					STRING_LITERAL142_tree = (Object)adaptor.create(STRING_LITERAL142);
					adaptor.addChild(root_0, STRING_LITERAL142_tree);
					}

					}
					break;
				case 4 :
					// PreprocessorParser.g:369:5: punctuator
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_punctuator_in_not_directive1894);
					punctuator143=punctuator();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, punctuator143.getTree());

					}
					break;
				case 5 :
					// PreprocessorParser.g:370:5: OTHER
					{
					root_0 = (Object)adaptor.nil();


					OTHER144=(Token)match(input,OTHER,FOLLOW_OTHER_in_not_directive1900); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					OTHER144_tree = (Object)adaptor.create(OTHER144);
					adaptor.addChild(root_0, OTHER144_tree);
					}

					}
					break;
				case 6 :
					// PreprocessorParser.g:371:5: IDENTIFIER
					{
					root_0 = (Object)adaptor.nil();


					IDENTIFIER145=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_not_directive1906); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					IDENTIFIER145_tree = (Object)adaptor.create(IDENTIFIER145);
					adaptor.addChild(root_0, IDENTIFIER145_tree);
					}

					}
					break;
				case 7 :
					// PreprocessorParser.g:372:5: EXTENDED_IDENTIFIER
					{
					root_0 = (Object)adaptor.nil();


					EXTENDED_IDENTIFIER146=(Token)match(input,EXTENDED_IDENTIFIER,FOLLOW_EXTENDED_IDENTIFIER_in_not_directive1912); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					EXTENDED_IDENTIFIER146_tree = (Object)adaptor.create(EXTENDED_IDENTIFIER146);
					adaptor.addChild(root_0, EXTENDED_IDENTIFIER146_tree);
					}

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "not_directive"


	public static class identifier_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "identifier"
	// PreprocessorParser.g:378:1: identifier : ( IDENTIFIER | EXTENDED_IDENTIFIER | pp_keyword );
	public final PreprocessorParser.identifier_return identifier() throws RecognitionException {
		PreprocessorParser.identifier_return retval = new PreprocessorParser.identifier_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token IDENTIFIER147=null;
		Token EXTENDED_IDENTIFIER148=null;
		ParserRuleReturnScope pp_keyword149 =null;

		Object IDENTIFIER147_tree=null;
		Object EXTENDED_IDENTIFIER148_tree=null;

		try {
			// PreprocessorParser.g:378:12: ( IDENTIFIER | EXTENDED_IDENTIFIER | pp_keyword )
			int alt68=3;
			switch ( input.LA(1) ) {
			case IDENTIFIER:
				{
				alt68=1;
				}
				break;
			case EXTENDED_IDENTIFIER:
				{
				alt68=2;
				}
				break;
			case DEFINE:
			case DEFINED:
			case ELIF:
			case ELSE:
			case ENDIF:
			case ERROR:
			case IF:
			case IFDEF:
			case IFNDEF:
			case INCLUDE:
			case LINE:
			case PRAGMA:
			case UNDEF:
				{
				alt68=3;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 68, 0, input);
				throw nvae;
			}
			switch (alt68) {
				case 1 :
					// PreprocessorParser.g:378:14: IDENTIFIER
					{
					root_0 = (Object)adaptor.nil();


					IDENTIFIER147=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier1926); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					IDENTIFIER147_tree = (Object)adaptor.create(IDENTIFIER147);
					adaptor.addChild(root_0, IDENTIFIER147_tree);
					}

					}
					break;
				case 2 :
					// PreprocessorParser.g:379:5: EXTENDED_IDENTIFIER
					{
					root_0 = (Object)adaptor.nil();


					EXTENDED_IDENTIFIER148=(Token)match(input,EXTENDED_IDENTIFIER,FOLLOW_EXTENDED_IDENTIFIER_in_identifier1932); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					EXTENDED_IDENTIFIER148_tree = (Object)adaptor.create(EXTENDED_IDENTIFIER148);
					adaptor.addChild(root_0, EXTENDED_IDENTIFIER148_tree);
					}

					}
					break;
				case 3 :
					// PreprocessorParser.g:380:5: pp_keyword
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_pp_keyword_in_identifier1938);
					pp_keyword149=pp_keyword();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, pp_keyword149.getTree());

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "identifier"


	public static class c_pp_keyword_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "c_pp_keyword"
	// PreprocessorParser.g:387:1: c_pp_keyword : ( IF | ELSE );
	public final PreprocessorParser.c_pp_keyword_return c_pp_keyword() throws RecognitionException {
		PreprocessorParser.c_pp_keyword_return retval = new PreprocessorParser.c_pp_keyword_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set150=null;

		Object set150_tree=null;

		try {
			// PreprocessorParser.g:387:14: ( IF | ELSE )
			// PreprocessorParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set150=input.LT(1);
			if ( input.LA(1)==ELSE||input.LA(1)==IF ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set150));
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "c_pp_keyword"


	public static class pp_notc_keyword_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "pp_notc_keyword"
	// PreprocessorParser.g:392:1: pp_notc_keyword : ( DEFINE | DEFINED | ELIF | ENDIF | ERROR | IFDEF | IFNDEF | INCLUDE | LINE | PRAGMA | UNDEF );
	public final PreprocessorParser.pp_notc_keyword_return pp_notc_keyword() throws RecognitionException {
		PreprocessorParser.pp_notc_keyword_return retval = new PreprocessorParser.pp_notc_keyword_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set151=null;

		Object set151_tree=null;

		try {
			// PreprocessorParser.g:392:17: ( DEFINE | DEFINED | ELIF | ENDIF | ERROR | IFDEF | IFNDEF | INCLUDE | LINE | PRAGMA | UNDEF )
			// PreprocessorParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set151=input.LT(1);
			if ( (input.LA(1) >= DEFINE && input.LA(1) <= DEFINED)||input.LA(1)==ELIF||input.LA(1)==ENDIF||input.LA(1)==ERROR||(input.LA(1) >= IFDEF && input.LA(1) <= IFNDEF)||input.LA(1)==INCLUDE||input.LA(1)==LINE||input.LA(1)==PRAGMA||input.LA(1)==UNDEF ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set151));
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "pp_notc_keyword"


	public static class pp_keyword_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "pp_keyword"
	// PreprocessorParser.g:406:1: pp_keyword : ( pp_notc_keyword | c_pp_keyword );
	public final PreprocessorParser.pp_keyword_return pp_keyword() throws RecognitionException {
		PreprocessorParser.pp_keyword_return retval = new PreprocessorParser.pp_keyword_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope pp_notc_keyword152 =null;
		ParserRuleReturnScope c_pp_keyword153 =null;


		try {
			// PreprocessorParser.g:406:12: ( pp_notc_keyword | c_pp_keyword )
			int alt69=2;
			int LA69_0 = input.LA(1);
			if ( ((LA69_0 >= DEFINE && LA69_0 <= DEFINED)||LA69_0==ELIF||LA69_0==ENDIF||LA69_0==ERROR||(LA69_0 >= IFDEF && LA69_0 <= IFNDEF)||LA69_0==INCLUDE||LA69_0==LINE||LA69_0==PRAGMA||LA69_0==UNDEF) ) {
				alt69=1;
			}
			else if ( (LA69_0==ELSE||LA69_0==IF) ) {
				alt69=2;
			}

			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 69, 0, input);
				throw nvae;
			}

			switch (alt69) {
				case 1 :
					// PreprocessorParser.g:406:14: pp_notc_keyword
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_pp_notc_keyword_in_pp_keyword2047);
					pp_notc_keyword152=pp_notc_keyword();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, pp_notc_keyword152.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:406:32: c_pp_keyword
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_c_pp_keyword_in_pp_keyword2051);
					c_pp_keyword153=c_pp_keyword();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, c_pp_keyword153.getTree());

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "pp_keyword"


	public static class pp_number_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "pp_number"
	// PreprocessorParser.g:410:1: pp_number : ( INTEGER_CONSTANT | FLOATING_CONSTANT | PP_NUMBER );
	public final PreprocessorParser.pp_number_return pp_number() throws RecognitionException {
		PreprocessorParser.pp_number_return retval = new PreprocessorParser.pp_number_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set154=null;

		Object set154_tree=null;

		try {
			// PreprocessorParser.g:410:11: ( INTEGER_CONSTANT | FLOATING_CONSTANT | PP_NUMBER )
			// PreprocessorParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set154=input.LT(1);
			if ( input.LA(1)==FLOATING_CONSTANT||input.LA(1)==INTEGER_CONSTANT||input.LA(1)==PP_NUMBER ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set154));
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "pp_number"


	public static class punctuator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "punctuator"
	// PreprocessorParser.g:417:1: punctuator : ( c_punctuator | civl_punctuator | cuda_punctuator );
	public final PreprocessorParser.punctuator_return punctuator() throws RecognitionException {
		PreprocessorParser.punctuator_return retval = new PreprocessorParser.punctuator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		ParserRuleReturnScope c_punctuator155 =null;
		ParserRuleReturnScope civl_punctuator156 =null;
		ParserRuleReturnScope cuda_punctuator157 =null;


		try {
			// PreprocessorParser.g:417:12: ( c_punctuator | civl_punctuator | cuda_punctuator )
			int alt70=3;
			switch ( input.LA(1) ) {
			case AMPERSAND:
			case AND:
			case ARROW:
			case ASSIGN:
			case BITANDEQ:
			case BITOR:
			case BITOREQ:
			case BITXOR:
			case BITXOREQ:
			case COLON:
			case COMMA:
			case DIV:
			case DIVEQ:
			case DOT:
			case DOTDOT:
			case ELLIPSIS:
			case EQUALS:
			case GT:
			case GTE:
			case HASH:
			case HASHHASH:
			case LCURLY:
			case LPAREN:
			case LSQUARE:
			case LT:
			case LTE:
			case MINUSMINUS:
			case MOD:
			case MODEQ:
			case NEQ:
			case NOT:
			case OR:
			case PLUS:
			case PLUSEQ:
			case PLUSPLUS:
			case QMARK:
			case RCURLY:
			case RPAREN:
			case RSQUARE:
			case SEMI:
			case SHIFTLEFT:
			case SHIFTLEFTEQ:
			case SHIFTRIGHT:
			case SHIFTRIGHTEQ:
			case STAR:
			case STAREQ:
			case SUB:
			case SUBEQ:
			case TILDE:
				{
				alt70=1;
				}
				break;
			case ANNOTATION_END:
			case ANNOTATION_START:
			case AT:
			case EQUIV_ACSL:
			case IMPLIES:
			case IMPLIES_ACSL:
			case INLINE_ANNOTATION_START:
			case LSLIST:
			case RSLIST:
			case XOR_ACSL:
				{
				alt70=2;
				}
				break;
			case LEXCON:
			case REXCON:
				{
				alt70=3;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 70, 0, input);
				throw nvae;
			}
			switch (alt70) {
				case 1 :
					// PreprocessorParser.g:417:14: c_punctuator
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_c_punctuator_in_punctuator2091);
					c_punctuator155=c_punctuator();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, c_punctuator155.getTree());

					}
					break;
				case 2 :
					// PreprocessorParser.g:418:5: civl_punctuator
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_civl_punctuator_in_punctuator2097);
					civl_punctuator156=civl_punctuator();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, civl_punctuator156.getTree());

					}
					break;
				case 3 :
					// PreprocessorParser.g:419:5: cuda_punctuator
					{
					root_0 = (Object)adaptor.nil();


					pushFollow(FOLLOW_cuda_punctuator_in_punctuator2103);
					cuda_punctuator157=cuda_punctuator();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, cuda_punctuator157.getTree());

					}
					break;

			}
			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "punctuator"


	public static class c_punctuator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "c_punctuator"
	// PreprocessorParser.g:423:1: c_punctuator : ( AMPERSAND | AND | ARROW | ASSIGN | BITANDEQ | BITOR | BITOREQ | BITXOR | BITXOREQ | COLON | COMMA | DIV | DIVEQ | ELLIPSIS | DOTDOT | DOT | EQUALS | GT | GTE | HASH | HASHHASH | LCURLY | LPAREN | LSQUARE | LT | LTE | MINUSMINUS | MOD | MODEQ | NEQ | NOT | OR | PLUS | PLUSEQ | PLUSPLUS | QMARK | RCURLY | RPAREN | RSQUARE | SEMI | SHIFTLEFT | SHIFTLEFTEQ | SHIFTRIGHT | SHIFTRIGHTEQ | STAR | STAREQ | SUB | SUBEQ | TILDE );
	public final PreprocessorParser.c_punctuator_return c_punctuator() throws RecognitionException {
		PreprocessorParser.c_punctuator_return retval = new PreprocessorParser.c_punctuator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set158=null;

		Object set158_tree=null;

		try {
			// PreprocessorParser.g:423:14: ( AMPERSAND | AND | ARROW | ASSIGN | BITANDEQ | BITOR | BITOREQ | BITXOR | BITXOREQ | COLON | COMMA | DIV | DIVEQ | ELLIPSIS | DOTDOT | DOT | EQUALS | GT | GTE | HASH | HASHHASH | LCURLY | LPAREN | LSQUARE | LT | LTE | MINUSMINUS | MOD | MODEQ | NEQ | NOT | OR | PLUS | PLUSEQ | PLUSPLUS | QMARK | RCURLY | RPAREN | RSQUARE | SEMI | SHIFTLEFT | SHIFTLEFTEQ | SHIFTRIGHT | SHIFTRIGHTEQ | STAR | STAREQ | SUB | SUBEQ | TILDE )
			// PreprocessorParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set158=input.LT(1);
			if ( (input.LA(1) >= AMPERSAND && input.LA(1) <= AND)||(input.LA(1) >= ARROW && input.LA(1) <= ASSIGN)||(input.LA(1) >= BITANDEQ && input.LA(1) <= BITXOREQ)||(input.LA(1) >= COLON && input.LA(1) <= COMMA)||(input.LA(1) >= DIV && input.LA(1) <= DOTDOT)||input.LA(1)==ELLIPSIS||input.LA(1)==EQUALS||(input.LA(1) >= GT && input.LA(1) <= HASHHASH)||input.LA(1)==LCURLY||input.LA(1)==LPAREN||(input.LA(1) >= LSQUARE && input.LA(1) <= LTE)||(input.LA(1) >= MINUSMINUS && input.LA(1) <= NEQ)||input.LA(1)==NOT||input.LA(1)==OR||(input.LA(1) >= PLUS && input.LA(1) <= PLUSPLUS)||(input.LA(1) >= QMARK && input.LA(1) <= RCURLY)||input.LA(1)==RPAREN||input.LA(1)==RSQUARE||(input.LA(1) >= SEMI && input.LA(1) <= STAREQ)||(input.LA(1) >= SUB && input.LA(1) <= TILDE) ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set158));
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "c_punctuator"


	public static class civl_punctuator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "civl_punctuator"
	// PreprocessorParser.g:474:1: civl_punctuator : ( ANNOTATION_END | ANNOTATION_START | AT | EQUIV_ACSL | IMPLIES | IMPLIES_ACSL | INLINE_ANNOTATION_START | LSLIST | RSLIST | XOR_ACSL );
	public final PreprocessorParser.civl_punctuator_return civl_punctuator() throws RecognitionException {
		PreprocessorParser.civl_punctuator_return retval = new PreprocessorParser.civl_punctuator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set159=null;

		Object set159_tree=null;

		try {
			// PreprocessorParser.g:474:17: ( ANNOTATION_END | ANNOTATION_START | AT | EQUIV_ACSL | IMPLIES | IMPLIES_ACSL | INLINE_ANNOTATION_START | LSLIST | RSLIST | XOR_ACSL )
			// PreprocessorParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set159=input.LT(1);
			if ( (input.LA(1) >= ANNOTATION_END && input.LA(1) <= ANNOTATION_START)||input.LA(1)==AT||input.LA(1)==EQUIV_ACSL||(input.LA(1) >= IMPLIES && input.LA(1) <= IMPLIES_ACSL)||input.LA(1)==INLINE_ANNOTATION_START||input.LA(1)==LSLIST||input.LA(1)==RSLIST||input.LA(1)==XOR_ACSL ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set159));
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "civl_punctuator"


	public static class cuda_punctuator_return extends ParserRuleReturnScope {
		Object tree;
		@Override
		public Object getTree() { return tree; }
	};


	// $ANTLR start "cuda_punctuator"
	// PreprocessorParser.g:486:1: cuda_punctuator : ( LEXCON | REXCON );
	public final PreprocessorParser.cuda_punctuator_return cuda_punctuator() throws RecognitionException {
		PreprocessorParser.cuda_punctuator_return retval = new PreprocessorParser.cuda_punctuator_return();
		retval.start = input.LT(1);

		Object root_0 = null;

		Token set160=null;

		Object set160_tree=null;

		try {
			// PreprocessorParser.g:486:17: ( LEXCON | REXCON )
			// PreprocessorParser.g:
			{
			root_0 = (Object)adaptor.nil();


			set160=input.LT(1);
			if ( input.LA(1)==LEXCON||input.LA(1)==REXCON ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (Object)adaptor.create(set160));
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

			retval.stop = input.LT(-1);

			if ( state.backtracking==0 ) {
			retval.tree = (Object)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "cuda_punctuator"

	// $ANTLR start synpred1_PreprocessorParser
	public final void synpred1_PreprocessorParser_fragment() throws RecognitionException {
		// PreprocessorParser.g:349:12: ( DEFINED )
		// PreprocessorParser.g:349:13: DEFINED
		{
		match(input,DEFINED,FOLLOW_DEFINED_in_synpred1_PreprocessorParser1809); if (state.failed) return;

		}

	}
	// $ANTLR end synpred1_PreprocessorParser

	// Delegated rules

	public final boolean synpred1_PreprocessorParser() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred1_PreprocessorParser_fragment(); // can never throw exception
		} catch (RecognitionException re) {
			System.err.println("impossible: "+re);
		}
		boolean success = !state.failed;
		input.rewind(start);
		state.backtracking--;
		state.failed=false;
		return success;
	}


	protected DFA19 dfa19 = new DFA19(this);
	protected DFA18 dfa18 = new DFA18(this);
	protected DFA26 dfa26 = new DFA26(this);
	protected DFA36 dfa36 = new DFA36(this);
	protected DFA35 dfa35 = new DFA35(this);
	protected DFA60 dfa60 = new DFA60(this);
	protected DFA65 dfa65 = new DFA65(this);
	static final String DFA19_eotS =
		"\4\uffff";
	static final String DFA19_eofS =
		"\4\uffff";
	static final String DFA19_minS =
		"\1\4\1\uffff\1\4\1\uffff";
	static final String DFA19_maxS =
		"\1\166\1\uffff\1\166\1\uffff";
	static final String DFA19_acceptS =
		"\1\uffff\1\1\1\uffff\1\2";
	static final String DFA19_specialS =
		"\4\uffff}>";
	static final String[] DFA19_transitionS = {
			"\14\1\3\uffff\3\1\1\2\6\1\3\uffff\10\1\2\uffff\1\1\2\uffff\4\1\7\uffff"+
			"\10\1\1\uffff\1\1\2\uffff\10\1\2\uffff\4\1\1\3\1\1\2\uffff\2\1\3\uffff"+
			"\13\1\1\uffff\14\1\2\uffff\1\2\1\1",
			"",
			"\14\1\3\uffff\3\1\1\2\6\1\3\uffff\10\1\2\uffff\1\1\2\uffff\4\1\7\uffff"+
			"\10\1\1\uffff\1\1\2\uffff\10\1\2\uffff\4\1\1\3\1\1\2\uffff\2\1\3\uffff"+
			"\13\1\1\uffff\14\1\2\uffff\1\2\1\1",
			""
	};

	static final short[] DFA19_eot = DFA.unpackEncodedString(DFA19_eotS);
	static final short[] DFA19_eof = DFA.unpackEncodedString(DFA19_eofS);
	static final char[] DFA19_min = DFA.unpackEncodedStringToUnsignedChars(DFA19_minS);
	static final char[] DFA19_max = DFA.unpackEncodedStringToUnsignedChars(DFA19_maxS);
	static final short[] DFA19_accept = DFA.unpackEncodedString(DFA19_acceptS);
	static final short[] DFA19_special = DFA.unpackEncodedString(DFA19_specialS);
	static final short[][] DFA19_transition;

	static {
		int numStates = DFA19_transitionS.length;
		DFA19_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA19_transition[i] = DFA.unpackEncodedString(DFA19_transitionS[i]);
		}
	}

	protected class DFA19 extends DFA {

		public DFA19(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 19;
			this.eot = DFA19_eot;
			this.eof = DFA19_eof;
			this.min = DFA19_min;
			this.max = DFA19_max;
			this.accept = DFA19_accept;
			this.special = DFA19_special;
			this.transition = DFA19_transition;
		}
		@Override
		public String getDescription() {
			return "219:18: ( (t+= wpptoken )* t+= pptoken )?";
		}
	}

	static final String DFA18_eotS =
		"\17\uffff";
	static final String DFA18_eofS =
		"\17\uffff";
	static final String DFA18_minS =
		"\14\4\1\uffff\1\4\1\uffff";
	static final String DFA18_maxS =
		"\14\166\1\uffff\1\166\1\uffff";
	static final String DFA18_acceptS =
		"\14\uffff\1\1\1\uffff\1\2";
	static final String DFA18_specialS =
		"\17\uffff}>";
	static final String[] DFA18_transitionS = {
			"\2\10\2\11\2\10\1\11\5\10\3\uffff\1\6\2\10\1\14\2\3\4\10\3\uffff\1\3"+
			"\1\10\1\4\1\3\1\10\1\11\1\3\1\2\2\uffff\1\5\2\uffff\4\10\7\uffff\1\1"+
			"\1\4\2\3\2\11\1\3\1\11\1\uffff\1\5\2\uffff\1\10\1\12\1\3\1\10\1\11\3"+
			"\10\2\uffff\4\10\1\uffff\1\10\2\uffff\1\10\1\13\3\uffff\3\10\1\5\1\3"+
			"\2\10\1\12\1\10\1\11\1\10\1\uffff\7\10\1\7\3\10\1\3\2\uffff\1\14\1\11",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			""
	};

	static final short[] DFA18_eot = DFA.unpackEncodedString(DFA18_eotS);
	static final short[] DFA18_eof = DFA.unpackEncodedString(DFA18_eofS);
	static final char[] DFA18_min = DFA.unpackEncodedStringToUnsignedChars(DFA18_minS);
	static final char[] DFA18_max = DFA.unpackEncodedStringToUnsignedChars(DFA18_maxS);
	static final short[] DFA18_accept = DFA.unpackEncodedString(DFA18_acceptS);
	static final short[] DFA18_special = DFA.unpackEncodedString(DFA18_specialS);
	static final short[][] DFA18_transition;

	static {
		int numStates = DFA18_transitionS.length;
		DFA18_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA18_transition[i] = DFA.unpackEncodedString(DFA18_transitionS[i]);
		}
	}

	protected class DFA18 extends DFA {

		public DFA18(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 18;
			this.eot = DFA18_eot;
			this.eof = DFA18_eof;
			this.min = DFA18_min;
			this.max = DFA18_max;
			this.accept = DFA18_accept;
			this.special = DFA18_special;
			this.transition = DFA18_transition;
		}
		@Override
		public String getDescription() {
			return "()* loopback of 219:20: (t+= wpptoken )*";
		}
	}

	static final String DFA26_eotS =
		"\6\uffff";
	static final String DFA26_eofS =
		"\6\uffff";
	static final String DFA26_minS =
		"\2\25\1\uffff\2\26\1\uffff";
	static final String DFA26_maxS =
		"\2\165\1\uffff\2\165\1\uffff";
	static final String DFA26_acceptS =
		"\2\uffff\1\2\2\uffff\1\1";
	static final String DFA26_specialS =
		"\6\uffff}>";
	static final String[] DFA26_transitionS = {
			"\1\3\1\1\114\uffff\1\2\21\uffff\1\1",
			"\1\3\1\1\114\uffff\1\2\21\uffff\1\1",
			"",
			"\1\4\2\5\7\uffff\1\5\1\2\2\5\2\uffff\2\5\20\uffff\4\5\2\uffff\1\5\7"+
			"\uffff\1\5\30\uffff\1\5\22\uffff\1\5\2\uffff\1\4",
			"\1\4\2\5\7\uffff\1\5\1\2\2\5\2\uffff\2\5\20\uffff\4\5\2\uffff\1\5\7"+
			"\uffff\1\5\30\uffff\1\5\22\uffff\1\5\2\uffff\1\4",
			""
	};

	static final short[] DFA26_eot = DFA.unpackEncodedString(DFA26_eotS);
	static final short[] DFA26_eof = DFA.unpackEncodedString(DFA26_eofS);
	static final char[] DFA26_min = DFA.unpackEncodedStringToUnsignedChars(DFA26_minS);
	static final char[] DFA26_max = DFA.unpackEncodedStringToUnsignedChars(DFA26_maxS);
	static final short[] DFA26_accept = DFA.unpackEncodedString(DFA26_acceptS);
	static final short[] DFA26_special = DFA.unpackEncodedString(DFA26_specialS);
	static final short[][] DFA26_transition;

	static {
		int numStates = DFA26_transitionS.length;
		DFA26_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA26_transition[i] = DFA.unpackEncodedString(DFA26_transitionS[i]);
		}
	}

	protected class DFA26 extends DFA {

		public DFA26(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 26;
			this.eot = DFA26_eot;
			this.eof = DFA26_eof;
			this.min = DFA26_min;
			this.max = DFA26_max;
			this.accept = DFA26_accept;
			this.special = DFA26_special;
			this.transition = DFA26_transition;
		}
		@Override
		public String getDescription() {
			return "()* loopback of 228:18: ( ( white )* COMMA ( white )* identifier )*";
		}
	}

	static final String DFA36_eotS =
		"\4\uffff";
	static final String DFA36_eofS =
		"\4\uffff";
	static final String DFA36_minS =
		"\1\4\1\uffff\1\4\1\uffff";
	static final String DFA36_maxS =
		"\1\166\1\uffff\1\166\1\uffff";
	static final String DFA36_acceptS =
		"\1\uffff\1\1\1\uffff\1\2";
	static final String DFA36_specialS =
		"\4\uffff}>";
	static final String[] DFA36_transitionS = {
			"\14\1\3\uffff\3\1\1\2\6\1\3\uffff\10\1\2\uffff\1\1\2\uffff\4\1\7\uffff"+
			"\10\1\1\uffff\1\1\2\uffff\10\1\2\uffff\4\1\1\3\1\1\2\uffff\2\1\3\uffff"+
			"\13\1\1\uffff\14\1\2\uffff\1\2\1\1",
			"",
			"\14\1\3\uffff\3\1\1\2\6\1\3\uffff\10\1\2\uffff\1\1\2\uffff\4\1\7\uffff"+
			"\10\1\1\uffff\1\1\2\uffff\10\1\2\uffff\4\1\1\3\1\1\2\uffff\2\1\3\uffff"+
			"\13\1\1\uffff\14\1\2\uffff\1\2\1\1",
			""
	};

	static final short[] DFA36_eot = DFA.unpackEncodedString(DFA36_eotS);
	static final short[] DFA36_eof = DFA.unpackEncodedString(DFA36_eofS);
	static final char[] DFA36_min = DFA.unpackEncodedStringToUnsignedChars(DFA36_minS);
	static final char[] DFA36_max = DFA.unpackEncodedStringToUnsignedChars(DFA36_maxS);
	static final short[] DFA36_accept = DFA.unpackEncodedString(DFA36_acceptS);
	static final short[] DFA36_special = DFA.unpackEncodedString(DFA36_specialS);
	static final short[][] DFA36_transition;

	static {
		int numStates = DFA36_transitionS.length;
		DFA36_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA36_transition[i] = DFA.unpackEncodedString(DFA36_transitionS[i]);
		}
	}

	protected class DFA36 extends DFA {

		public DFA36(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 36;
			this.eot = DFA36_eot;
			this.eof = DFA36_eof;
			this.min = DFA36_min;
			this.max = DFA36_max;
			this.accept = DFA36_accept;
			this.special = DFA36_special;
			this.transition = DFA36_transition;
		}
		@Override
		public String getDescription() {
			return "240:41: ( (t+= wpptoken )* t+= pptoken )?";
		}
	}

	static final String DFA35_eotS =
		"\17\uffff";
	static final String DFA35_eofS =
		"\17\uffff";
	static final String DFA35_minS =
		"\14\4\1\uffff\1\4\1\uffff";
	static final String DFA35_maxS =
		"\14\166\1\uffff\1\166\1\uffff";
	static final String DFA35_acceptS =
		"\14\uffff\1\1\1\uffff\1\2";
	static final String DFA35_specialS =
		"\17\uffff}>";
	static final String[] DFA35_transitionS = {
			"\2\10\2\11\2\10\1\11\5\10\3\uffff\1\6\2\10\1\14\2\3\4\10\3\uffff\1\3"+
			"\1\10\1\4\1\3\1\10\1\11\1\3\1\2\2\uffff\1\5\2\uffff\4\10\7\uffff\1\1"+
			"\1\4\2\3\2\11\1\3\1\11\1\uffff\1\5\2\uffff\1\10\1\12\1\3\1\10\1\11\3"+
			"\10\2\uffff\4\10\1\uffff\1\10\2\uffff\1\10\1\13\3\uffff\3\10\1\5\1\3"+
			"\2\10\1\12\1\10\1\11\1\10\1\uffff\7\10\1\7\3\10\1\3\2\uffff\1\14\1\11",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			"",
			"\14\14\3\uffff\3\14\1\15\6\14\3\uffff\10\14\2\uffff\1\14\2\uffff\4\14"+
			"\7\uffff\10\14\1\uffff\1\14\2\uffff\10\14\2\uffff\4\14\1\16\1\14\2\uffff"+
			"\2\14\3\uffff\13\14\1\uffff\14\14\2\uffff\1\15\1\14",
			""
	};

	static final short[] DFA35_eot = DFA.unpackEncodedString(DFA35_eotS);
	static final short[] DFA35_eof = DFA.unpackEncodedString(DFA35_eofS);
	static final char[] DFA35_min = DFA.unpackEncodedStringToUnsignedChars(DFA35_minS);
	static final char[] DFA35_max = DFA.unpackEncodedStringToUnsignedChars(DFA35_maxS);
	static final short[] DFA35_accept = DFA.unpackEncodedString(DFA35_acceptS);
	static final short[] DFA35_special = DFA.unpackEncodedString(DFA35_specialS);
	static final short[][] DFA35_transition;

	static {
		int numStates = DFA35_transitionS.length;
		DFA35_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA35_transition[i] = DFA.unpackEncodedString(DFA35_transitionS[i]);
		}
	}

	protected class DFA35 extends DFA {

		public DFA35(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 35;
			this.eot = DFA35_eot;
			this.eof = DFA35_eof;
			this.min = DFA35_min;
			this.max = DFA35_max;
			this.accept = DFA35_accept;
			this.special = DFA35_special;
			this.transition = DFA35_transition;
		}
		@Override
		public String getDescription() {
			return "()* loopback of 240:43: (t+= wpptoken )*";
		}
	}

	static final String DFA60_eotS =
		"\4\uffff";
	static final String DFA60_eofS =
		"\4\uffff";
	static final String DFA60_minS =
		"\2\4\2\uffff";
	static final String DFA60_maxS =
		"\2\166\2\uffff";
	static final String DFA60_acceptS =
		"\2\uffff\1\2\1\1";
	static final String DFA60_specialS =
		"\4\uffff}>";
	static final String[] DFA60_transitionS = {
			"\14\3\3\uffff\3\3\1\1\6\3\3\uffff\10\3\2\uffff\1\3\2\uffff\4\3\7\uffff"+
			"\10\3\1\uffff\1\3\2\uffff\10\3\2\uffff\4\3\1\2\1\3\2\uffff\2\3\3\uffff"+
			"\13\3\1\uffff\14\3\2\uffff\1\1\1\3",
			"\14\3\3\uffff\3\3\1\1\6\3\3\uffff\10\3\2\uffff\1\3\2\uffff\4\3\7\uffff"+
			"\10\3\1\uffff\1\3\2\uffff\10\3\2\uffff\4\3\1\2\1\3\2\uffff\2\3\3\uffff"+
			"\13\3\1\uffff\14\3\2\uffff\1\1\1\3",
			"",
			""
	};

	static final short[] DFA60_eot = DFA.unpackEncodedString(DFA60_eotS);
	static final short[] DFA60_eof = DFA.unpackEncodedString(DFA60_eofS);
	static final char[] DFA60_min = DFA.unpackEncodedStringToUnsignedChars(DFA60_minS);
	static final char[] DFA60_max = DFA.unpackEncodedStringToUnsignedChars(DFA60_maxS);
	static final short[] DFA60_accept = DFA.unpackEncodedString(DFA60_acceptS);
	static final short[] DFA60_special = DFA.unpackEncodedString(DFA60_specialS);
	static final short[][] DFA60_transition;

	static {
		int numStates = DFA60_transitionS.length;
		DFA60_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA60_transition[i] = DFA.unpackEncodedString(DFA60_transitionS[i]);
		}
	}

	protected class DFA60 extends DFA {

		public DFA60(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 60;
			this.eot = DFA60_eot;
			this.eof = DFA60_eof;
			this.min = DFA60_min;
			this.max = DFA60_max;
			this.accept = DFA60_accept;
			this.special = DFA60_special;
			this.transition = DFA60_transition;
		}
		@Override
		public String getDescription() {
			return "()* loopback of 339:17: ( ( white )* ppdExpr )*";
		}
	}

	static final String DFA65_eotS =
		"\37\uffff";
	static final String DFA65_eofS =
		"\37\uffff";
	static final String DFA65_minS =
		"\2\4\1\uffff\1\4\4\0\1\4\6\0\1\uffff\7\4\2\0\1\4\5\0";
	static final String DFA65_maxS =
		"\2\166\1\uffff\1\166\4\0\1\166\6\0\1\uffff\7\166\2\0\1\166\5\0";
	static final String DFA65_acceptS =
		"\2\uffff\1\2\14\uffff\1\1\17\uffff";
	static final String DFA65_specialS =
		"\4\uffff\1\0\1\2\1\4\1\6\1\uffff\1\10\1\1\1\3\1\5\1\7\1\11\10\uffff\1"+
		"\12\1\13\1\uffff\1\14\1\15\1\16\1\17\1\20}>";
	static final String[] DFA65_transitionS = {
			"\14\2\3\uffff\3\2\1\uffff\1\2\1\1\4\2\3\uffff\10\2\2\uffff\1\2\2\uffff"+
			"\4\2\7\uffff\10\2\1\uffff\1\2\2\uffff\10\2\2\uffff\4\2\1\uffff\1\2\2"+
			"\uffff\2\2\3\uffff\13\2\1\uffff\14\2\3\uffff\1\2",
			"\14\2\3\uffff\3\2\1\3\1\11\1\6\4\2\3\uffff\1\11\1\2\1\7\1\11\2\2\1\11"+
			"\1\5\2\uffff\1\2\2\uffff\4\2\7\uffff\1\4\1\7\2\11\2\2\1\11\1\2\1\uffff"+
			"\1\2\2\uffff\2\2\1\11\1\10\4\2\2\uffff\6\2\2\uffff\2\2\3\uffff\4\2\1"+
			"\11\6\2\1\uffff\13\2\1\11\2\uffff\1\3\1\2",
			"",
			"\14\2\3\uffff\3\2\1\3\1\16\1\14\4\2\3\uffff\1\16\1\2\1\15\1\16\2\2\1"+
			"\16\1\13\2\uffff\1\2\2\uffff\4\2\7\uffff\1\12\1\15\2\16\2\2\1\16\1\2"+
			"\1\uffff\1\2\2\uffff\2\2\1\16\1\10\4\2\2\uffff\6\2\2\uffff\2\2\3\uffff"+
			"\4\2\1\16\6\2\1\uffff\13\2\1\16\2\uffff\1\3\1\2",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff",
			"\14\2\3\uffff\3\2\1\20\1\25\1\23\4\2\3\uffff\1\25\1\2\1\24\1\25\2\2"+
			"\1\25\1\22\2\uffff\1\2\2\uffff\4\2\7\uffff\1\21\1\24\2\25\2\2\1\25\1"+
			"\2\1\uffff\1\2\2\uffff\2\2\1\25\5\2\2\uffff\6\2\2\uffff\2\2\3\uffff\4"+
			"\2\1\25\6\2\1\uffff\13\2\1\25\2\uffff\1\20\1\2",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff",
			"",
			"\14\2\3\uffff\3\2\1\20\1\25\1\23\4\2\3\uffff\1\25\1\2\1\24\1\25\2\2"+
			"\1\25\1\22\2\uffff\1\2\2\uffff\4\2\7\uffff\1\21\1\24\2\25\2\2\1\25\1"+
			"\2\1\uffff\1\2\2\uffff\2\2\1\25\5\2\2\uffff\6\2\2\uffff\2\2\3\uffff\4"+
			"\2\1\25\6\2\1\uffff\13\2\1\25\2\uffff\1\20\1\2",
			"\14\2\3\uffff\3\2\1\26\6\2\3\uffff\10\2\2\uffff\1\2\2\uffff\4\2\7\uffff"+
			"\10\2\1\uffff\1\2\2\uffff\10\2\2\uffff\6\2\2\uffff\2\2\3\uffff\10\2\1"+
			"\27\2\2\1\uffff\14\2\2\uffff\1\26\1\2",
			"\14\2\3\uffff\3\2\1\26\6\2\3\uffff\10\2\2\uffff\1\2\2\uffff\4\2\7\uffff"+
			"\10\2\1\uffff\1\2\2\uffff\10\2\2\uffff\6\2\2\uffff\2\2\3\uffff\10\2\1"+
			"\30\2\2\1\uffff\14\2\2\uffff\1\26\1\2",
			"\14\2\3\uffff\3\2\1\31\6\2\3\uffff\10\2\2\uffff\1\2\2\uffff\4\2\7\uffff"+
			"\10\2\1\uffff\1\2\2\uffff\10\2\2\uffff\6\2\2\uffff\2\2\3\uffff\10\2\1"+
			"\32\2\2\1\uffff\14\2\2\uffff\1\31\1\2",
			"\14\2\3\uffff\3\2\1\26\6\2\3\uffff\10\2\2\uffff\1\2\2\uffff\4\2\7\uffff"+
			"\10\2\1\uffff\1\2\2\uffff\10\2\2\uffff\6\2\2\uffff\2\2\3\uffff\10\2\1"+
			"\33\2\2\1\uffff\14\2\2\uffff\1\26\1\2",
			"\14\2\3\uffff\3\2\1\26\6\2\3\uffff\10\2\2\uffff\1\2\2\uffff\4\2\7\uffff"+
			"\10\2\1\uffff\1\2\2\uffff\10\2\2\uffff\6\2\2\uffff\2\2\3\uffff\10\2\1"+
			"\34\2\2\1\uffff\14\2\2\uffff\1\26\1\2",
			"\14\2\3\uffff\3\2\1\26\6\2\3\uffff\10\2\2\uffff\1\2\2\uffff\4\2\7\uffff"+
			"\10\2\1\uffff\1\2\2\uffff\10\2\2\uffff\6\2\2\uffff\2\2\3\uffff\10\2\1"+
			"\35\2\2\1\uffff\14\2\2\uffff\1\26\1\2",
			"\1\uffff",
			"\1\uffff",
			"\14\2\3\uffff\3\2\1\31\6\2\3\uffff\10\2\2\uffff\1\2\2\uffff\4\2\7\uffff"+
			"\10\2\1\uffff\1\2\2\uffff\10\2\2\uffff\6\2\2\uffff\2\2\3\uffff\10\2\1"+
			"\36\2\2\1\uffff\14\2\2\uffff\1\31\1\2",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff",
			"\1\uffff"
	};

	static final short[] DFA65_eot = DFA.unpackEncodedString(DFA65_eotS);
	static final short[] DFA65_eof = DFA.unpackEncodedString(DFA65_eofS);
	static final char[] DFA65_min = DFA.unpackEncodedStringToUnsignedChars(DFA65_minS);
	static final char[] DFA65_max = DFA.unpackEncodedStringToUnsignedChars(DFA65_maxS);
	static final short[] DFA65_accept = DFA.unpackEncodedString(DFA65_acceptS);
	static final short[] DFA65_special = DFA.unpackEncodedString(DFA65_specialS);
	static final short[][] DFA65_transition;

	static {
		int numStates = DFA65_transitionS.length;
		DFA65_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA65_transition[i] = DFA.unpackEncodedString(DFA65_transitionS[i]);
		}
	}

	protected class DFA65 extends DFA {

		public DFA65(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 65;
			this.eot = DFA65_eot;
			this.eof = DFA65_eof;
			this.min = DFA65_min;
			this.max = DFA65_max;
			this.accept = DFA65_accept;
			this.special = DFA65_special;
			this.transition = DFA65_transition;
		}
		@Override
		public String getDescription() {
			return "349:1: ppdExpr : ( ( DEFINED )=> definedExpr | pptoken );";
		}
		@Override
		public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
			TokenStream input = (TokenStream)_input;
			int _s = s;
			switch ( s ) {
					case 0 : 
						int LA65_4 = input.LA(1);
						 
						int index65_4 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_4);
						if ( s>=0 ) return s;
						break;

					case 1 : 
						int LA65_10 = input.LA(1);
						 
						int index65_10 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_10);
						if ( s>=0 ) return s;
						break;

					case 2 : 
						int LA65_5 = input.LA(1);
						 
						int index65_5 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_5);
						if ( s>=0 ) return s;
						break;

					case 3 : 
						int LA65_11 = input.LA(1);
						 
						int index65_11 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_11);
						if ( s>=0 ) return s;
						break;

					case 4 : 
						int LA65_6 = input.LA(1);
						 
						int index65_6 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_6);
						if ( s>=0 ) return s;
						break;

					case 5 : 
						int LA65_12 = input.LA(1);
						 
						int index65_12 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_12);
						if ( s>=0 ) return s;
						break;

					case 6 : 
						int LA65_7 = input.LA(1);
						 
						int index65_7 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_7);
						if ( s>=0 ) return s;
						break;

					case 7 : 
						int LA65_13 = input.LA(1);
						 
						int index65_13 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_13);
						if ( s>=0 ) return s;
						break;

					case 8 : 
						int LA65_9 = input.LA(1);
						 
						int index65_9 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_9);
						if ( s>=0 ) return s;
						break;

					case 9 : 
						int LA65_14 = input.LA(1);
						 
						int index65_14 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_14);
						if ( s>=0 ) return s;
						break;

					case 10 : 
						int LA65_23 = input.LA(1);
						 
						int index65_23 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_23);
						if ( s>=0 ) return s;
						break;

					case 11 : 
						int LA65_24 = input.LA(1);
						 
						int index65_24 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_24);
						if ( s>=0 ) return s;
						break;

					case 12 : 
						int LA65_26 = input.LA(1);
						 
						int index65_26 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_26);
						if ( s>=0 ) return s;
						break;

					case 13 : 
						int LA65_27 = input.LA(1);
						 
						int index65_27 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_27);
						if ( s>=0 ) return s;
						break;

					case 14 : 
						int LA65_28 = input.LA(1);
						 
						int index65_28 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_28);
						if ( s>=0 ) return s;
						break;

					case 15 : 
						int LA65_29 = input.LA(1);
						 
						int index65_29 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_29);
						if ( s>=0 ) return s;
						break;

					case 16 : 
						int LA65_30 = input.LA(1);
						 
						int index65_30 = input.index();
						input.rewind();
						s = -1;
						if ( (synpred1_PreprocessorParser()) ) {s = 15;}
						else if ( (true) ) {s = 2;}
						 
						input.seek(index65_30);
						if ( s>=0 ) return s;
						break;
			}
			if (state.backtracking>0) {state.failed=true; return -1;}
			NoViableAltException nvae =
				new NoViableAltException(getDescription(), 65, _s, input);
			error(nvae);
			throw nvae;
		}
	}

	public static final BitSet FOLLOW_whiteBlock_in_file546 = new BitSet(new long[]{0xFFFFFFFFFFBFFFF0L,0xFFDFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_itemList_in_file549 = new BitSet(new long[]{0x0000000000000000L});
	public static final BitSet FOLLOW_EOF_in_file551 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_directiveBlock_in_itemList584 = new BitSet(new long[]{0xFFFFFFFFFFBFFFF0L,0xFFDFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_itemList_in_itemList586 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_textBlock_in_itemList592 = new BitSet(new long[]{0x0000800000000002L});
	public static final BitSet FOLLOW_directiveBlock_in_itemList596 = new BitSet(new long[]{0xFFFFFFFFFFBFFFF0L,0xFFDFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_itemList_in_itemList598 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_white_in_whiteBlock617 = new BitSet(new long[]{0x0000000000400002L,0x0020000000000000L});
	public static final BitSet FOLLOW_textSegment_in_textBlock638 = new BitSet(new long[]{0xFFFF7FFFFFBFFFF2L,0xFFDFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_NEWLINE_in_textSegment659 = new BitSet(new long[]{0x0000000000400002L,0x0020000000000000L});
	public static final BitSet FOLLOW_white_in_textSegment661 = new BitSet(new long[]{0x0000000000400002L,0x0020000000000000L});
	public static final BitSet FOLLOW_set_in_textSegment668 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0xFFFFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_NEWLINE_in_textSegment685 = new BitSet(new long[]{0x0000000000400002L,0x0020000000000000L});
	public static final BitSet FOLLOW_white_in_textSegment687 = new BitSet(new long[]{0x0000000000400002L,0x0020000000000000L});
	public static final BitSet FOLLOW_directive_in_directiveBlock699 = new BitSet(new long[]{0x0000000000400002L,0x0020000000000000L});
	public static final BitSet FOLLOW_whiteBlock_in_directiveBlock701 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_HASH_in_directive713 = new BitSet(new long[]{0xFF01E4F21EF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_white_in_directive716 = new BitSet(new long[]{0xFF01E4F21EF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_directiveSuffix_in_directive720 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_macrodef_in_directiveSuffix731 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_macroundef_in_directiveSuffix737 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_includeline_in_directiveSuffix743 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pragmaline_in_directiveSuffix749 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_errorline_in_directiveSuffix755 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_lineline_in_directiveSuffix761 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ifdefblock_in_directiveSuffix767 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ifblock_in_directiveSuffix773 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ifndefblock_in_directiveSuffix779 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_nondirective_in_directiveSuffix785 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_not_directive_in_nondirective800 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_wpptoken_in_nondirective804 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_NEWLINE_in_nondirective807 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_NEWLINE_in_nondirective823 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_DEFINE_in_macrodef842 = new BitSet(new long[]{0x0000000000400000L,0x0020000000000000L});
	public static final BitSet FOLLOW_white_in_macrodef844 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_identifier_in_macrodef849 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040080L});
	public static final BitSet FOLLOW_paramlist_in_macrodef857 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_macrobody_in_macrodef859 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_NEWLINE_in_macrodef880 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_white_in_macrodef901 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_macrobody_in_macrodef903 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_white_in_macrobody931 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_pptoken_in_macrobody943 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_wpptoken_in_macrobody948 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_pptoken_in_macrobody953 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_macrobody957 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_macrobody960 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_NEWLINE_in_macrobody984 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_LPAREN_in_paramlist1007 = new BitSet(new long[]{0x4F0000CF01C00000L,0x0024000880000040L});
	public static final BitSet FOLLOW_white_in_paramlist1009 = new BitSet(new long[]{0x4F0000CF01C00000L,0x0024000880000040L});
	public static final BitSet FOLLOW_RPAREN_in_paramlist1019 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ELLIPSIS_in_paramlist1033 = new BitSet(new long[]{0x0000000000400000L,0x0020000800000000L});
	public static final BitSet FOLLOW_white_in_paramlist1035 = new BitSet(new long[]{0x0000000000400000L,0x0020000800000000L});
	public static final BitSet FOLLOW_RPAREN_in_paramlist1038 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_identifier_in_paramlist1054 = new BitSet(new long[]{0x0000000000600000L,0x0020000800000000L});
	public static final BitSet FOLLOW_white_in_paramlist1057 = new BitSet(new long[]{0x0000000000600000L,0x0020000000000000L});
	public static final BitSet FOLLOW_COMMA_in_paramlist1060 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_white_in_paramlist1062 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_identifier_in_paramlist1065 = new BitSet(new long[]{0x0000000000600000L,0x0020000800000000L});
	public static final BitSet FOLLOW_white_in_paramlist1069 = new BitSet(new long[]{0x0000000000600000L,0x0020000800000000L});
	public static final BitSet FOLLOW_RPAREN_in_paramlist1080 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_COMMA_in_paramlist1099 = new BitSet(new long[]{0x0000000200400000L,0x0020000000000000L});
	public static final BitSet FOLLOW_white_in_paramlist1101 = new BitSet(new long[]{0x0000000200400000L,0x0020000000000000L});
	public static final BitSet FOLLOW_ELLIPSIS_in_paramlist1104 = new BitSet(new long[]{0x0000000000400000L,0x0020000800000000L});
	public static final BitSet FOLLOW_white_in_paramlist1106 = new BitSet(new long[]{0x0000000000400000L,0x0020000800000000L});
	public static final BitSet FOLLOW_RPAREN_in_paramlist1109 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_UNDEF_in_macroundef1153 = new BitSet(new long[]{0x0000000000400000L,0x0020000000000000L});
	public static final BitSet FOLLOW_white_in_macroundef1155 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_identifier_in_macroundef1158 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_macroundef1160 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_macroundef1163 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_INCLUDE_in_includeline1186 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_white_in_includeline1188 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_pptoken_in_includeline1193 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_wpptoken_in_includeline1198 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_pptoken_in_includeline1203 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_includeline1211 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_includeline1214 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_PRAGMA_in_pragmaline1239 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_wpptoken_in_pragmaline1242 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_NEWLINE_in_pragmaline1245 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ERROR_in_errorline1271 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_wpptoken_in_errorline1273 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_NEWLINE_in_errorline1276 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_LINE_in_lineline1296 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_wpptoken_in_lineline1298 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_NEWLINE_in_lineline1301 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_IFDEF_in_ifdefblock1323 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_white_in_ifdefblock1325 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_identifier_in_ifdefblock1330 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_ifdefblock1332 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_ifdefblock1335 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0xFFFFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_if_section_in_ifdefblock1343 = new BitSet(new long[]{0x0000000D00000000L});
	public static final BitSet FOLLOW_if_suffix_in_ifdefblock1347 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_IFNDEF_in_ifndefblock1385 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_white_in_ifndefblock1387 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_identifier_in_ifndefblock1392 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_ifndefblock1394 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_ifndefblock1397 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0xFFFFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_if_section_in_ifndefblock1405 = new BitSet(new long[]{0x0000000D00000000L});
	public static final BitSet FOLLOW_if_suffix_in_ifndefblock1409 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_IF_in_ifblock1448 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_white_in_ifblock1455 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_expr_in_ifblock1460 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_ifblock1462 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_ifblock1465 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0xFFFFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_if_section_in_ifblock1473 = new BitSet(new long[]{0x0000000D00000000L});
	public static final BitSet FOLLOW_if_suffix_in_ifblock1477 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_whiteBlock_in_if_section1516 = new BitSet(new long[]{0xFFFFFFFFFFBFFFF0L,0xFFDFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_section_body_in_if_section1519 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_textBlock_in_section_body1532 = new BitSet(new long[]{0x0000800000000000L});
	public static final BitSet FOLLOW_subsection_in_section_body1535 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_HASH_in_subsection1548 = new BitSet(new long[]{0xFF01E4F21EF8FFF2L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_white_in_subsection1551 = new BitSet(new long[]{0xFF01E4F21EF8FFF2L,0x0067FFBFF8CFCFF2L});
	public static final BitSet FOLLOW_directiveSuffix_in_subsection1561 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0xFFFFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_whiteBlock_in_subsection1563 = new BitSet(new long[]{0xFFFFFFFFFFBFFFF0L,0xFFDFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_section_body_in_subsection1566 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ENDIF_in_if_suffix1581 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_if_suffix1583 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_if_suffix1586 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ELIF_in_if_suffix1602 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_white_in_if_suffix1604 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_expr_in_if_suffix1607 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_if_suffix1609 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_if_suffix1612 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0xFFFFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_if_section_in_if_suffix1614 = new BitSet(new long[]{0x0000000D00000000L});
	public static final BitSet FOLLOW_if_suffix_in_if_suffix1616 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ELSE_in_if_suffix1650 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_if_suffix1657 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_if_suffix1660 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0xFFFFFFFFFFFFFFFFL,0xFFFFFFFFFFFFFFFFL,0x000000003FFFFFFFL});
	public static final BitSet FOLLOW_if_section_in_if_suffix1662 = new BitSet(new long[]{0x0000000800000000L});
	public static final BitSet FOLLOW_ENDIF_in_if_suffix1664 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_white_in_if_suffix1666 = new BitSet(new long[]{0x0000000000400000L,0x0020000000040000L});
	public static final BitSet FOLLOW_NEWLINE_in_if_suffix1669 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pptoken_in_wpptoken1711 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_white_in_wpptoken1715 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ppdExpr_in_expr1727 = new BitSet(new long[]{0xFF01E4FF1FF8FFF2L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_white_in_expr1730 = new BitSet(new long[]{0xFF01E4FF1FF8FFF0L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_ppdExpr_in_expr1733 = new BitSet(new long[]{0xFF01E4FF1FF8FFF2L,0x0067FFBFF8CBCFF2L});
	public static final BitSet FOLLOW_DEFINED_in_definedExpr1753 = new BitSet(new long[]{0x4F0000CD01C00000L,0x00240000800000C0L});
	public static final BitSet FOLLOW_white_in_definedExpr1755 = new BitSet(new long[]{0x4F0000CD01C00000L,0x00240000800000C0L});
	public static final BitSet FOLLOW_identifier_in_definedExpr1765 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_LPAREN_in_definedExpr1773 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_white_in_definedExpr1776 = new BitSet(new long[]{0x4F0000CD01C00000L,0x0024000080000040L});
	public static final BitSet FOLLOW_identifier_in_definedExpr1780 = new BitSet(new long[]{0x0000000000400000L,0x0020000800000000L});
	public static final BitSet FOLLOW_white_in_definedExpr1782 = new BitSet(new long[]{0x0000000000400000L,0x0020000800000000L});
	public static final BitSet FOLLOW_RPAREN_in_definedExpr1786 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_definedExpr_in_ppdExpr1813 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pptoken_in_ppdExpr1819 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_identifier_in_pptoken1833 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pp_number_in_pptoken1839 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_CHARACTER_CONSTANT_in_pptoken1845 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_pptoken1851 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_punctuator_in_pptoken1857 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_OTHER_in_pptoken1863 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pp_number_in_not_directive1876 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_CHARACTER_CONSTANT_in_not_directive1882 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_STRING_LITERAL_in_not_directive1888 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_punctuator_in_not_directive1894 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_OTHER_in_not_directive1900 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_IDENTIFIER_in_not_directive1906 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_EXTENDED_IDENTIFIER_in_not_directive1912 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_IDENTIFIER_in_identifier1926 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_EXTENDED_IDENTIFIER_in_identifier1932 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pp_keyword_in_identifier1938 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_pp_notc_keyword_in_pp_keyword2047 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_c_pp_keyword_in_pp_keyword2051 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_c_punctuator_in_punctuator2091 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_civl_punctuator_in_punctuator2097 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_cuda_punctuator_in_punctuator2103 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_DEFINED_in_synpred1_PreprocessorParser1809 = new BitSet(new long[]{0x0000000000000002L});
}