// $ANTLR 3.5.2 C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g 2020-06-03 14:02:36
package de.dhbw.compiler.antlrxparser;

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 XParser extends Parser {
	public static final String[] tokenNames = new String[] {
		"<invalid>", "<EOR>", "<DOWN>", "<UP>", "DECL", "DECLIST", "DIGIT", "ESCAPE", 
		"EXPR", "FLOATCONST", "ID", "INTCONST", "INVALID", "MODIFIER", "PROGRAM", 
		"STAT", "STATLIST", "STRINGCONST", "TYPE", "WS", "'('", "')'", "'*'", 
		"'+'", "'-'", "'.'", "'/'", "':'", "':='", "';'", "'<'", "'='", "'>'", 
		"'begin'", "'else'", "'end'", "'float'", "'for'", "'if'", "'int'", "'print'", 
		"'program'", "'read'", "'string'", "'then'", "'while'"
	};
	public static final int EOF=-1;
	public static final int T__20=20;
	public static final int T__21=21;
	public static final int T__22=22;
	public static final int T__23=23;
	public static final int T__24=24;
	public static final int T__25=25;
	public static final int T__26=26;
	public static final int T__27=27;
	public static final int T__28=28;
	public static final int T__29=29;
	public static final int T__30=30;
	public static final int T__31=31;
	public static final int T__32=32;
	public static final int T__33=33;
	public static final int T__34=34;
	public static final int T__35=35;
	public static final int T__36=36;
	public static final int T__37=37;
	public static final int T__38=38;
	public static final int T__39=39;
	public static final int T__40=40;
	public static final int T__41=41;
	public static final int T__42=42;
	public static final int T__43=43;
	public static final int T__44=44;
	public static final int T__45=45;
	public static final int DECL=4;
	public static final int DECLIST=5;
	public static final int DIGIT=6;
	public static final int ESCAPE=7;
	public static final int EXPR=8;
	public static final int FLOATCONST=9;
	public static final int ID=10;
	public static final int INTCONST=11;
	public static final int INVALID=12;
	public static final int MODIFIER=13;
	public static final int PROGRAM=14;
	public static final int STAT=15;
	public static final int STATLIST=16;
	public static final int STRINGCONST=17;
	public static final int TYPE=18;
	public static final int WS=19;

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

	// delegators


	public XParser(TokenStream input) {
		this(input, new RecognizerSharedState());
	}
	public XParser(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 XParser.tokenNames; }
	@Override public String getGrammarFileName() { return "C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g"; }


	public static class program_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "program"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:63:1: program : 'program' ID ';' decllist statlist '.' EOF -> ^( PROGRAM ID decllist statlist ) ;
	public final XParser.program_return program() throws RecognitionException {
		XParser.program_return retval = new XParser.program_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token string_literal1=null;
		Token ID2=null;
		Token char_literal3=null;
		Token char_literal6=null;
		Token EOF7=null;
		ParserRuleReturnScope decllist4 =null;
		ParserRuleReturnScope statlist5 =null;

		CommonTree string_literal1_tree=null;
		CommonTree ID2_tree=null;
		CommonTree char_literal3_tree=null;
		CommonTree char_literal6_tree=null;
		CommonTree EOF7_tree=null;
		RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
		RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29");
		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
		RewriteRuleTokenStream stream_41=new RewriteRuleTokenStream(adaptor,"token 41");
		RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
		RewriteRuleSubtreeStream stream_decllist=new RewriteRuleSubtreeStream(adaptor,"rule decllist");
		RewriteRuleSubtreeStream stream_statlist=new RewriteRuleSubtreeStream(adaptor,"rule statlist");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:63:8: ( 'program' ID ';' decllist statlist '.' EOF -> ^( PROGRAM ID decllist statlist ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:63:17: 'program' ID ';' decllist statlist '.' EOF
			{
			string_literal1=(Token)match(input,41,FOLLOW_41_in_program473); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_41.add(string_literal1);

			ID2=(Token)match(input,ID,FOLLOW_ID_in_program475); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_ID.add(ID2);

			char_literal3=(Token)match(input,29,FOLLOW_29_in_program477); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_29.add(char_literal3);

			pushFollow(FOLLOW_decllist_in_program479);
			decllist4=decllist();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_decllist.add(decllist4.getTree());
			pushFollow(FOLLOW_statlist_in_program481);
			statlist5=statlist();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_statlist.add(statlist5.getTree());
			char_literal6=(Token)match(input,25,FOLLOW_25_in_program483); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_25.add(char_literal6);

			EOF7=(Token)match(input,EOF,FOLLOW_EOF_in_program485); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_EOF.add(EOF7);

			// AST REWRITE
			// elements: ID, statlist, decllist
			// 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 = (CommonTree)adaptor.nil();
			// 63:60: -> ^( PROGRAM ID decllist statlist )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:63:63: ^( PROGRAM ID decllist statlist )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(PROGRAM, "PROGRAM"), root_1);
				adaptor.addChild(root_1, stream_ID.nextNode());
				adaptor.addChild(root_1, stream_decllist.nextTree());
				adaptor.addChild(root_1, stream_statlist.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


	public static class decllist_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "decllist"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:66:1: decllist : decl decllist -> ^( DECLIST decl decllist ) ;
	public final XParser.decllist_return decllist() throws RecognitionException {
		XParser.decllist_return retval = new XParser.decllist_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		ParserRuleReturnScope decl8 =null;
		ParserRuleReturnScope decllist9 =null;

		RewriteRuleSubtreeStream stream_decl=new RewriteRuleSubtreeStream(adaptor,"rule decl");
		RewriteRuleSubtreeStream stream_decllist=new RewriteRuleSubtreeStream(adaptor,"rule decllist");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:66:9: ( decl decllist -> ^( DECLIST decl decllist ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:66:17: decl decllist
			{
			pushFollow(FOLLOW_decl_in_decllist511);
			decl8=decl();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_decl.add(decl8.getTree());
			pushFollow(FOLLOW_decllist_in_decllist513);
			decllist9=decllist();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_decllist.add(decllist9.getTree());
			// AST REWRITE
			// elements: decl, decllist
			// 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 = (CommonTree)adaptor.nil();
			// 66:31: -> ^( DECLIST decl decllist )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:66:34: ^( DECLIST decl decllist )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DECLIST, "DECLIST"), root_1);
				adaptor.addChild(root_1, stream_decl.nextTree());
				adaptor.addChild(root_1, stream_decllist.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


	public static class decl_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "decl"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:67:1: decl : modifier ID ':' type ';' -> ^( DECL modifier ID type ) ;
	public final XParser.decl_return decl() throws RecognitionException {
		XParser.decl_return retval = new XParser.decl_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token ID11=null;
		Token char_literal12=null;
		Token char_literal14=null;
		ParserRuleReturnScope modifier10 =null;
		ParserRuleReturnScope type13 =null;

		CommonTree ID11_tree=null;
		CommonTree char_literal12_tree=null;
		CommonTree char_literal14_tree=null;
		RewriteRuleTokenStream stream_27=new RewriteRuleTokenStream(adaptor,"token 27");
		RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29");
		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
		RewriteRuleSubtreeStream stream_modifier=new RewriteRuleSubtreeStream(adaptor,"rule modifier");
		RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:67:5: ( modifier ID ':' type ';' -> ^( DECL modifier ID type ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:67:17: modifier ID ':' type ';'
			{
			pushFollow(FOLLOW_modifier_in_decl539);
			modifier10=modifier();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_modifier.add(modifier10.getTree());
			ID11=(Token)match(input,ID,FOLLOW_ID_in_decl541); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_ID.add(ID11);

			char_literal12=(Token)match(input,27,FOLLOW_27_in_decl543); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_27.add(char_literal12);

			pushFollow(FOLLOW_type_in_decl545);
			type13=type();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_type.add(type13.getTree());
			char_literal14=(Token)match(input,29,FOLLOW_29_in_decl547); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_29.add(char_literal14);

			// AST REWRITE
			// elements: modifier, type, ID
			// 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 = (CommonTree)adaptor.nil();
			// 67:42: -> ^( DECL modifier ID type )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:67:45: ^( DECL modifier ID type )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DECL, "DECL"), root_1);
				adaptor.addChild(root_1, stream_modifier.nextTree());
				adaptor.addChild(root_1, stream_ID.nextNode());
				adaptor.addChild(root_1, stream_type.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


	public static class modifier_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "modifier"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:1: modifier : ( 'read' ( 'print' )? | 'read' | 'print' );
	public final XParser.modifier_return modifier() throws RecognitionException {
		XParser.modifier_return retval = new XParser.modifier_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token string_literal15=null;
		Token string_literal16=null;
		Token string_literal17=null;
		Token string_literal18=null;

		CommonTree string_literal15_tree=null;
		CommonTree string_literal16_tree=null;
		CommonTree string_literal17_tree=null;
		CommonTree string_literal18_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:9: ( 'read' ( 'print' )? | 'read' | 'print' )
			int alt2=3;
			int LA2_0 = input.LA(1);
			if ( (LA2_0==42) ) {
				int LA2_1 = input.LA(2);
				if ( (synpred2_X()) ) {
					alt2=1;
				}
				else if ( (synpred3_X()) ) {
					alt2=2;
				}

				else {
					if (state.backtracking>0) {state.failed=true; return retval;}
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 2, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}
			else if ( (LA2_0==40) ) {
				alt2=3;
			}

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

			switch (alt2) {
				case 1 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:17: 'read' ( 'print' )?
					{
					root_0 = (CommonTree)adaptor.nil();


					string_literal15=(Token)match(input,42,FOLLOW_42_in_modifier571); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal15_tree = (CommonTree)adaptor.create(string_literal15);
					adaptor.addChild(root_0, string_literal15_tree);
					}

					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:24: ( 'print' )?
					int alt1=2;
					int LA1_0 = input.LA(1);
					if ( (LA1_0==40) ) {
						alt1=1;
					}
					switch (alt1) {
						case 1 :
							// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:24: 'print'
							{
							string_literal16=(Token)match(input,40,FOLLOW_40_in_modifier573); if (state.failed) return retval;
							if ( state.backtracking==0 ) {
							string_literal16_tree = (CommonTree)adaptor.create(string_literal16);
							adaptor.addChild(root_0, string_literal16_tree);
							}

							}
							break;

					}

					}
					break;
				case 2 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:35: 'read'
					{
					root_0 = (CommonTree)adaptor.nil();


					string_literal17=(Token)match(input,42,FOLLOW_42_in_modifier578); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal17_tree = (CommonTree)adaptor.create(string_literal17);
					adaptor.addChild(root_0, string_literal17_tree);
					}

					}
					break;
				case 3 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:44: 'print'
					{
					root_0 = (CommonTree)adaptor.nil();


					string_literal18=(Token)match(input,40,FOLLOW_40_in_modifier582); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					string_literal18_tree = (CommonTree)adaptor.create(string_literal18);
					adaptor.addChild(root_0, string_literal18_tree);
					}

					}
					break;

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

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


	public static class type_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "type"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:69:1: type : ( 'int' | 'float' | 'string' );
	public final XParser.type_return type() throws RecognitionException {
		XParser.type_return retval = new XParser.type_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token set19=null;

		CommonTree set19_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:69:5: ( 'int' | 'float' | 'string' )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:
			{
			root_0 = (CommonTree)adaptor.nil();


			set19=input.LT(1);
			if ( input.LA(1)==36||input.LA(1)==39||input.LA(1)==43 ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set19));
				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 = (CommonTree)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "type"


	public static class statlist_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "statlist"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:72:1: statlist : 'begin' ( stat ';' )* 'end' -> ^( STATLIST ( stat )* ) ;
	public final XParser.statlist_return statlist() throws RecognitionException {
		XParser.statlist_return retval = new XParser.statlist_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token string_literal20=null;
		Token char_literal22=null;
		Token string_literal23=null;
		ParserRuleReturnScope stat21 =null;

		CommonTree string_literal20_tree=null;
		CommonTree char_literal22_tree=null;
		CommonTree string_literal23_tree=null;
		RewriteRuleTokenStream stream_33=new RewriteRuleTokenStream(adaptor,"token 33");
		RewriteRuleTokenStream stream_35=new RewriteRuleTokenStream(adaptor,"token 35");
		RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29");
		RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:72:9: ( 'begin' ( stat ';' )* 'end' -> ^( STATLIST ( stat )* ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:72:17: 'begin' ( stat ';' )* 'end'
			{
			string_literal20=(Token)match(input,33,FOLLOW_33_in_statlist620); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_33.add(string_literal20);

			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:72:25: ( stat ';' )*
			loop3:
			while (true) {
				int alt3=2;
				int LA3_0 = input.LA(1);
				if ( (LA3_0==ID||LA3_0==33||(LA3_0 >= 37 && LA3_0 <= 38)||LA3_0==45) ) {
					alt3=1;
				}

				switch (alt3) {
				case 1 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:72:26: stat ';'
					{
					pushFollow(FOLLOW_stat_in_statlist623);
					stat21=stat();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_stat.add(stat21.getTree());
					char_literal22=(Token)match(input,29,FOLLOW_29_in_statlist625); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_29.add(char_literal22);

					}
					break;

				default :
					break loop3;
				}
			}

			string_literal23=(Token)match(input,35,FOLLOW_35_in_statlist629); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_35.add(string_literal23);

			// AST REWRITE
			// elements: stat
			// 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 = (CommonTree)adaptor.nil();
			// 72:43: -> ^( STATLIST ( stat )* )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:72:46: ^( STATLIST ( stat )* )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(STATLIST, "STATLIST"), root_1);
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:72:57: ( stat )*
				while ( stream_stat.hasNext() ) {
					adaptor.addChild(root_1, stream_stat.nextTree());
				}
				stream_stat.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


	public static class stat_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "stat"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:73:1: stat : ( assignstat | condstat | whilestat | forstat | statlist );
	public final XParser.stat_return stat() throws RecognitionException {
		XParser.stat_return retval = new XParser.stat_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		ParserRuleReturnScope assignstat24 =null;
		ParserRuleReturnScope condstat25 =null;
		ParserRuleReturnScope whilestat26 =null;
		ParserRuleReturnScope forstat27 =null;
		ParserRuleReturnScope statlist28 =null;


		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:73:5: ( assignstat | condstat | whilestat | forstat | statlist )
			int alt4=5;
			switch ( input.LA(1) ) {
			case ID:
				{
				alt4=1;
				}
				break;
			case 38:
				{
				alt4=2;
				}
				break;
			case 45:
				{
				alt4=3;
				}
				break;
			case 37:
				{
				alt4=4;
				}
				break;
			case 33:
				{
				alt4=5;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 4, 0, input);
				throw nvae;
			}
			switch (alt4) {
				case 1 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:73:17: assignstat
					{
					root_0 = (CommonTree)adaptor.nil();


					pushFollow(FOLLOW_assignstat_in_stat654);
					assignstat24=assignstat();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, assignstat24.getTree());

					}
					break;
				case 2 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:73:30: condstat
					{
					root_0 = (CommonTree)adaptor.nil();


					pushFollow(FOLLOW_condstat_in_stat658);
					condstat25=condstat();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, condstat25.getTree());

					}
					break;
				case 3 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:73:41: whilestat
					{
					root_0 = (CommonTree)adaptor.nil();


					pushFollow(FOLLOW_whilestat_in_stat662);
					whilestat26=whilestat();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, whilestat26.getTree());

					}
					break;
				case 4 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:73:53: forstat
					{
					root_0 = (CommonTree)adaptor.nil();


					pushFollow(FOLLOW_forstat_in_stat666);
					forstat27=forstat();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, forstat27.getTree());

					}
					break;
				case 5 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:73:63: statlist
					{
					root_0 = (CommonTree)adaptor.nil();


					pushFollow(FOLLOW_statlist_in_stat670);
					statlist28=statlist();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, statlist28.getTree());

					}
					break;

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

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


	public static class assignstat_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "assignstat"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:74:1: assignstat : ID ':=' expr -> ^( ':=' ID expr ) ;
	public final XParser.assignstat_return assignstat() throws RecognitionException {
		XParser.assignstat_return retval = new XParser.assignstat_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token ID29=null;
		Token string_literal30=null;
		ParserRuleReturnScope expr31 =null;

		CommonTree ID29_tree=null;
		CommonTree string_literal30_tree=null;
		RewriteRuleTokenStream stream_28=new RewriteRuleTokenStream(adaptor,"token 28");
		RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:74:11: ( ID ':=' expr -> ^( ':=' ID expr ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:74:17: ID ':=' expr
			{
			ID29=(Token)match(input,ID,FOLLOW_ID_in_assignstat680); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_ID.add(ID29);

			string_literal30=(Token)match(input,28,FOLLOW_28_in_assignstat682); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_28.add(string_literal30);

			pushFollow(FOLLOW_expr_in_assignstat684);
			expr31=expr();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_expr.add(expr31.getTree());
			// AST REWRITE
			// elements: 28, expr, ID
			// 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 = (CommonTree)adaptor.nil();
			// 74:30: -> ^( ':=' ID expr )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:74:33: ^( ':=' ID expr )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot(stream_28.nextNode(), root_1);
				adaptor.addChild(root_1, stream_ID.nextNode());
				adaptor.addChild(root_1, stream_expr.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


	public static class condstat_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "condstat"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:1: condstat : 'if' cond 'then' stat ( condElseStat )? -> ^( 'if' cond stat ( condElseStat )? ) ;
	public final XParser.condstat_return condstat() throws RecognitionException {
		XParser.condstat_return retval = new XParser.condstat_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token string_literal32=null;
		Token string_literal34=null;
		ParserRuleReturnScope cond33 =null;
		ParserRuleReturnScope stat35 =null;
		ParserRuleReturnScope condElseStat36 =null;

		CommonTree string_literal32_tree=null;
		CommonTree string_literal34_tree=null;
		RewriteRuleTokenStream stream_44=new RewriteRuleTokenStream(adaptor,"token 44");
		RewriteRuleTokenStream stream_38=new RewriteRuleTokenStream(adaptor,"token 38");
		RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");
		RewriteRuleSubtreeStream stream_condElseStat=new RewriteRuleSubtreeStream(adaptor,"rule condElseStat");
		RewriteRuleSubtreeStream stream_cond=new RewriteRuleSubtreeStream(adaptor,"rule cond");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:9: ( 'if' cond 'then' stat ( condElseStat )? -> ^( 'if' cond stat ( condElseStat )? ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:17: 'if' cond 'then' stat ( condElseStat )?
			{
			string_literal32=(Token)match(input,38,FOLLOW_38_in_condstat706); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_38.add(string_literal32);

			pushFollow(FOLLOW_cond_in_condstat708);
			cond33=cond();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_cond.add(cond33.getTree());
			string_literal34=(Token)match(input,44,FOLLOW_44_in_condstat710); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_44.add(string_literal34);

			pushFollow(FOLLOW_stat_in_condstat712);
			stat35=stat();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_stat.add(stat35.getTree());
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:39: ( condElseStat )?
			int alt5=2;
			int LA5_0 = input.LA(1);
			if ( (LA5_0==34) ) {
				int LA5_1 = input.LA(2);
				if ( (synpred11_X()) ) {
					alt5=1;
				}
			}
			switch (alt5) {
				case 1 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:39: condElseStat
					{
					pushFollow(FOLLOW_condElseStat_in_condstat714);
					condElseStat36=condElseStat();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_condElseStat.add(condElseStat36.getTree());
					}
					break;

			}

			// AST REWRITE
			// elements: stat, 38, cond, condElseStat
			// 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 = (CommonTree)adaptor.nil();
			// 75:53: -> ^( 'if' cond stat ( condElseStat )? )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:56: ^( 'if' cond stat ( condElseStat )? )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot(stream_38.nextNode(), root_1);
				adaptor.addChild(root_1, stream_cond.nextTree());
				adaptor.addChild(root_1, stream_stat.nextTree());
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:73: ( condElseStat )?
				if ( stream_condElseStat.hasNext() ) {
					adaptor.addChild(root_1, stream_condElseStat.nextTree());
				}
				stream_condElseStat.reset();

				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


	public static class condElseStat_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "condElseStat"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:76:1: condElseStat : 'else' stat -> ^( 'else' stat ) ;
	public final XParser.condElseStat_return condElseStat() throws RecognitionException {
		XParser.condElseStat_return retval = new XParser.condElseStat_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token string_literal37=null;
		ParserRuleReturnScope stat38 =null;

		CommonTree string_literal37_tree=null;
		RewriteRuleTokenStream stream_34=new RewriteRuleTokenStream(adaptor,"token 34");
		RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:76:13: ( 'else' stat -> ^( 'else' stat ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:76:17: 'else' stat
			{
			string_literal37=(Token)match(input,34,FOLLOW_34_in_condElseStat737); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_34.add(string_literal37);

			pushFollow(FOLLOW_stat_in_condElseStat739);
			stat38=stat();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_stat.add(stat38.getTree());
			// AST REWRITE
			// elements: 34, stat
			// 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 = (CommonTree)adaptor.nil();
			// 76:29: -> ^( 'else' stat )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:76:32: ^( 'else' stat )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot(stream_34.nextNode(), root_1);
				adaptor.addChild(root_1, stream_stat.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


	public static class whilestat_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "whilestat"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:77:1: whilestat : 'while' '(' cond ')' stat -> ^( 'while' cond stat ) ;
	public final XParser.whilestat_return whilestat() throws RecognitionException {
		XParser.whilestat_return retval = new XParser.whilestat_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token string_literal39=null;
		Token char_literal40=null;
		Token char_literal42=null;
		ParserRuleReturnScope cond41 =null;
		ParserRuleReturnScope stat43 =null;

		CommonTree string_literal39_tree=null;
		CommonTree char_literal40_tree=null;
		CommonTree char_literal42_tree=null;
		RewriteRuleTokenStream stream_45=new RewriteRuleTokenStream(adaptor,"token 45");
		RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20");
		RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
		RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");
		RewriteRuleSubtreeStream stream_cond=new RewriteRuleSubtreeStream(adaptor,"rule cond");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:77:10: ( 'while' '(' cond ')' stat -> ^( 'while' cond stat ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:77:17: 'while' '(' cond ')' stat
			{
			string_literal39=(Token)match(input,45,FOLLOW_45_in_whilestat758); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_45.add(string_literal39);

			char_literal40=(Token)match(input,20,FOLLOW_20_in_whilestat760); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_20.add(char_literal40);

			pushFollow(FOLLOW_cond_in_whilestat762);
			cond41=cond();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_cond.add(cond41.getTree());
			char_literal42=(Token)match(input,21,FOLLOW_21_in_whilestat764); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_21.add(char_literal42);

			pushFollow(FOLLOW_stat_in_whilestat766);
			stat43=stat();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_stat.add(stat43.getTree());
			// AST REWRITE
			// elements: stat, 45, cond
			// 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 = (CommonTree)adaptor.nil();
			// 77:43: -> ^( 'while' cond stat )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:77:46: ^( 'while' cond stat )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot(stream_45.nextNode(), root_1);
				adaptor.addChild(root_1, stream_cond.nextTree());
				adaptor.addChild(root_1, stream_stat.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


	public static class forstat_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "forstat"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:78:1: forstat : 'for' '(' assignstat ';' cond ';' assignstat ')' stat -> ^( 'for' assignstat cond assignstat stat ) ;
	public final XParser.forstat_return forstat() throws RecognitionException {
		XParser.forstat_return retval = new XParser.forstat_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token string_literal44=null;
		Token char_literal45=null;
		Token char_literal47=null;
		Token char_literal49=null;
		Token char_literal51=null;
		ParserRuleReturnScope assignstat46 =null;
		ParserRuleReturnScope cond48 =null;
		ParserRuleReturnScope assignstat50 =null;
		ParserRuleReturnScope stat52 =null;

		CommonTree string_literal44_tree=null;
		CommonTree char_literal45_tree=null;
		CommonTree char_literal47_tree=null;
		CommonTree char_literal49_tree=null;
		CommonTree char_literal51_tree=null;
		RewriteRuleTokenStream stream_37=new RewriteRuleTokenStream(adaptor,"token 37");
		RewriteRuleTokenStream stream_29=new RewriteRuleTokenStream(adaptor,"token 29");
		RewriteRuleTokenStream stream_20=new RewriteRuleTokenStream(adaptor,"token 20");
		RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
		RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");
		RewriteRuleSubtreeStream stream_cond=new RewriteRuleSubtreeStream(adaptor,"rule cond");
		RewriteRuleSubtreeStream stream_assignstat=new RewriteRuleSubtreeStream(adaptor,"rule assignstat");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:78:8: ( 'for' '(' assignstat ';' cond ';' assignstat ')' stat -> ^( 'for' assignstat cond assignstat stat ) )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:78:17: 'for' '(' assignstat ';' cond ';' assignstat ')' stat
			{
			string_literal44=(Token)match(input,37,FOLLOW_37_in_forstat789); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_37.add(string_literal44);

			char_literal45=(Token)match(input,20,FOLLOW_20_in_forstat791); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_20.add(char_literal45);

			pushFollow(FOLLOW_assignstat_in_forstat793);
			assignstat46=assignstat();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_assignstat.add(assignstat46.getTree());
			char_literal47=(Token)match(input,29,FOLLOW_29_in_forstat795); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_29.add(char_literal47);

			pushFollow(FOLLOW_cond_in_forstat797);
			cond48=cond();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_cond.add(cond48.getTree());
			char_literal49=(Token)match(input,29,FOLLOW_29_in_forstat799); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_29.add(char_literal49);

			pushFollow(FOLLOW_assignstat_in_forstat801);
			assignstat50=assignstat();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_assignstat.add(assignstat50.getTree());
			char_literal51=(Token)match(input,21,FOLLOW_21_in_forstat803); if (state.failed) return retval; 
			if ( state.backtracking==0 ) stream_21.add(char_literal51);

			pushFollow(FOLLOW_stat_in_forstat805);
			stat52=stat();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) stream_stat.add(stat52.getTree());
			// AST REWRITE
			// elements: assignstat, 37, stat, assignstat, cond
			// 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 = (CommonTree)adaptor.nil();
			// 79:17: -> ^( 'for' assignstat cond assignstat stat )
			{
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:79:20: ^( 'for' assignstat cond assignstat stat )
				{
				CommonTree root_1 = (CommonTree)adaptor.nil();
				root_1 = (CommonTree)adaptor.becomeRoot(stream_37.nextNode(), root_1);
				adaptor.addChild(root_1, stream_assignstat.nextTree());
				adaptor.addChild(root_1, stream_cond.nextTree());
				adaptor.addChild(root_1, stream_assignstat.nextTree());
				adaptor.addChild(root_1, stream_stat.nextTree());
				adaptor.addChild(root_0, root_1);
				}

			}


			retval.tree = root_0;
			}

			}

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

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


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


	// $ANTLR start "expr"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:81:1: expr : ( expr2 '+' expr -> ^( '+' expr2 expr ) | expr2 '-' expr -> ^( '-' expr2 expr ) | expr2 -> ^( expr2 ) );
	public final XParser.expr_return expr() throws RecognitionException {
		XParser.expr_return retval = new XParser.expr_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token char_literal54=null;
		Token char_literal57=null;
		ParserRuleReturnScope expr253 =null;
		ParserRuleReturnScope expr55 =null;
		ParserRuleReturnScope expr256 =null;
		ParserRuleReturnScope expr58 =null;
		ParserRuleReturnScope expr259 =null;

		CommonTree char_literal54_tree=null;
		CommonTree char_literal57_tree=null;
		RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23");
		RewriteRuleTokenStream stream_24=new RewriteRuleTokenStream(adaptor,"token 24");
		RewriteRuleSubtreeStream stream_expr2=new RewriteRuleSubtreeStream(adaptor,"rule expr2");
		RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:81:5: ( expr2 '+' expr -> ^( '+' expr2 expr ) | expr2 '-' expr -> ^( '-' expr2 expr ) | expr2 -> ^( expr2 ) )
			int alt6=3;
			switch ( input.LA(1) ) {
			case FLOATCONST:
			case INTCONST:
				{
				int LA6_1 = input.LA(2);
				if ( (synpred12_X()) ) {
					alt6=1;
				}
				else if ( (synpred13_X()) ) {
					alt6=2;
				}
				else if ( (true) ) {
					alt6=3;
				}

				}
				break;
			case 24:
				{
				int LA6_2 = input.LA(2);
				if ( (synpred12_X()) ) {
					alt6=1;
				}
				else if ( (synpred13_X()) ) {
					alt6=2;
				}
				else if ( (true) ) {
					alt6=3;
				}

				}
				break;
			case STRINGCONST:
				{
				int LA6_3 = input.LA(2);
				if ( (synpred12_X()) ) {
					alt6=1;
				}
				else if ( (synpred13_X()) ) {
					alt6=2;
				}
				else if ( (true) ) {
					alt6=3;
				}

				}
				break;
			case 20:
				{
				int LA6_4 = input.LA(2);
				if ( (synpred12_X()) ) {
					alt6=1;
				}
				else if ( (synpred13_X()) ) {
					alt6=2;
				}
				else if ( (true) ) {
					alt6=3;
				}

				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 6, 0, input);
				throw nvae;
			}
			switch (alt6) {
				case 1 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:81:13: expr2 '+' expr
					{
					pushFollow(FOLLOW_expr2_in_expr848);
					expr253=expr2();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr2.add(expr253.getTree());
					char_literal54=(Token)match(input,23,FOLLOW_23_in_expr850); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_23.add(char_literal54);

					pushFollow(FOLLOW_expr_in_expr852);
					expr55=expr();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr.add(expr55.getTree());
					// AST REWRITE
					// elements: expr, 23, expr2
					// 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 = (CommonTree)adaptor.nil();
					// 81:35: -> ^( '+' expr2 expr )
					{
						// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:81:38: ^( '+' expr2 expr )
						{
						CommonTree root_1 = (CommonTree)adaptor.nil();
						root_1 = (CommonTree)adaptor.becomeRoot(stream_23.nextNode(), root_1);
						adaptor.addChild(root_1, stream_expr2.nextTree());
						adaptor.addChild(root_1, stream_expr.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 2 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:82:15: expr2 '-' expr
					{
					pushFollow(FOLLOW_expr2_in_expr885);
					expr256=expr2();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr2.add(expr256.getTree());
					char_literal57=(Token)match(input,24,FOLLOW_24_in_expr887); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_24.add(char_literal57);

					pushFollow(FOLLOW_expr_in_expr889);
					expr58=expr();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr.add(expr58.getTree());
					// AST REWRITE
					// elements: 24, expr, expr2
					// 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 = (CommonTree)adaptor.nil();
					// 82:34: -> ^( '-' expr2 expr )
					{
						// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:82:37: ^( '-' expr2 expr )
						{
						CommonTree root_1 = (CommonTree)adaptor.nil();
						root_1 = (CommonTree)adaptor.becomeRoot(stream_24.nextNode(), root_1);
						adaptor.addChild(root_1, stream_expr2.nextTree());
						adaptor.addChild(root_1, stream_expr.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 3 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:83:15: expr2
					{
					pushFollow(FOLLOW_expr2_in_expr919);
					expr259=expr2();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr2.add(expr259.getTree());
					// AST REWRITE
					// elements: expr2
					// 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 = (CommonTree)adaptor.nil();
					// 83:37: -> ^( expr2 )
					{
						// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:83:40: ^( expr2 )
						{
						CommonTree root_1 = (CommonTree)adaptor.nil();
						root_1 = (CommonTree)adaptor.becomeRoot(stream_expr2.nextNode(), root_1);
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;

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

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


	public static class expr2_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "expr2"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:84:1: expr2 : ( expr3 '*' expr2 -> ^( '*' expr3 expr2 ) | expr3 '/' expr2 -> ^( '/' expr3 expr2 ) | expr3 -> ^( expr3 ) );
	public final XParser.expr2_return expr2() throws RecognitionException {
		XParser.expr2_return retval = new XParser.expr2_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token char_literal61=null;
		Token char_literal64=null;
		ParserRuleReturnScope expr360 =null;
		ParserRuleReturnScope expr262 =null;
		ParserRuleReturnScope expr363 =null;
		ParserRuleReturnScope expr265 =null;
		ParserRuleReturnScope expr366 =null;

		CommonTree char_literal61_tree=null;
		CommonTree char_literal64_tree=null;
		RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");
		RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
		RewriteRuleSubtreeStream stream_expr3=new RewriteRuleSubtreeStream(adaptor,"rule expr3");
		RewriteRuleSubtreeStream stream_expr2=new RewriteRuleSubtreeStream(adaptor,"rule expr2");

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:84:6: ( expr3 '*' expr2 -> ^( '*' expr3 expr2 ) | expr3 '/' expr2 -> ^( '/' expr3 expr2 ) | expr3 -> ^( expr3 ) )
			int alt7=3;
			switch ( input.LA(1) ) {
			case FLOATCONST:
			case INTCONST:
				{
				int LA7_1 = input.LA(2);
				if ( (synpred14_X()) ) {
					alt7=1;
				}
				else if ( (synpred15_X()) ) {
					alt7=2;
				}
				else if ( (true) ) {
					alt7=3;
				}

				}
				break;
			case 24:
				{
				int LA7_2 = input.LA(2);
				if ( (synpred14_X()) ) {
					alt7=1;
				}
				else if ( (synpred15_X()) ) {
					alt7=2;
				}
				else if ( (true) ) {
					alt7=3;
				}

				}
				break;
			case STRINGCONST:
				{
				int LA7_3 = input.LA(2);
				if ( (synpred14_X()) ) {
					alt7=1;
				}
				else if ( (synpred15_X()) ) {
					alt7=2;
				}
				else if ( (true) ) {
					alt7=3;
				}

				}
				break;
			case 20:
				{
				int LA7_4 = input.LA(2);
				if ( (synpred14_X()) ) {
					alt7=1;
				}
				else if ( (synpred15_X()) ) {
					alt7=2;
				}
				else if ( (true) ) {
					alt7=3;
				}

				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 7, 0, input);
				throw nvae;
			}
			switch (alt7) {
				case 1 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:84:13: expr3 '*' expr2
					{
					pushFollow(FOLLOW_expr3_in_expr2952);
					expr360=expr3();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr3.add(expr360.getTree());
					char_literal61=(Token)match(input,22,FOLLOW_22_in_expr2954); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_22.add(char_literal61);

					pushFollow(FOLLOW_expr2_in_expr2956);
					expr262=expr2();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr2.add(expr262.getTree());
					// AST REWRITE
					// elements: 22, expr2, expr3
					// 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 = (CommonTree)adaptor.nil();
					// 84:31: -> ^( '*' expr3 expr2 )
					{
						// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:84:34: ^( '*' expr3 expr2 )
						{
						CommonTree root_1 = (CommonTree)adaptor.nil();
						root_1 = (CommonTree)adaptor.becomeRoot(stream_22.nextNode(), root_1);
						adaptor.addChild(root_1, stream_expr3.nextTree());
						adaptor.addChild(root_1, stream_expr2.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 2 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:85:15: expr3 '/' expr2
					{
					pushFollow(FOLLOW_expr3_in_expr2984);
					expr363=expr3();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr3.add(expr363.getTree());
					char_literal64=(Token)match(input,26,FOLLOW_26_in_expr2986); if (state.failed) return retval; 
					if ( state.backtracking==0 ) stream_26.add(char_literal64);

					pushFollow(FOLLOW_expr2_in_expr2988);
					expr265=expr2();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr2.add(expr265.getTree());
					// AST REWRITE
					// elements: expr3, expr2, 26
					// 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 = (CommonTree)adaptor.nil();
					// 85:33: -> ^( '/' expr3 expr2 )
					{
						// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:85:36: ^( '/' expr3 expr2 )
						{
						CommonTree root_1 = (CommonTree)adaptor.nil();
						root_1 = (CommonTree)adaptor.becomeRoot(stream_26.nextNode(), root_1);
						adaptor.addChild(root_1, stream_expr3.nextTree());
						adaptor.addChild(root_1, stream_expr2.nextTree());
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;
				case 3 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:86:15: expr3
					{
					pushFollow(FOLLOW_expr3_in_expr21016);
					expr366=expr3();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) stream_expr3.add(expr366.getTree());
					// AST REWRITE
					// elements: expr3
					// 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 = (CommonTree)adaptor.nil();
					// 86:37: -> ^( expr3 )
					{
						// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:86:40: ^( expr3 )
						{
						CommonTree root_1 = (CommonTree)adaptor.nil();
						root_1 = (CommonTree)adaptor.becomeRoot(stream_expr3.nextNode(), root_1);
						adaptor.addChild(root_0, root_1);
						}

					}


					retval.tree = root_0;
					}

					}
					break;

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

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


	public static class expr3_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "expr3"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:87:1: expr3 : ( number | '-' number | STRINGCONST | '(' ! expr ^ ')' );
	public final XParser.expr3_return expr3() throws RecognitionException {
		XParser.expr3_return retval = new XParser.expr3_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token char_literal68=null;
		Token STRINGCONST70=null;
		Token char_literal71=null;
		Token char_literal73=null;
		ParserRuleReturnScope number67 =null;
		ParserRuleReturnScope number69 =null;
		ParserRuleReturnScope expr72 =null;

		CommonTree char_literal68_tree=null;
		CommonTree STRINGCONST70_tree=null;
		CommonTree char_literal71_tree=null;
		CommonTree char_literal73_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:87:6: ( number | '-' number | STRINGCONST | '(' ! expr ^ ')' )
			int alt8=4;
			switch ( input.LA(1) ) {
			case FLOATCONST:
			case INTCONST:
				{
				alt8=1;
				}
				break;
			case 24:
				{
				alt8=2;
				}
				break;
			case STRINGCONST:
				{
				alt8=3;
				}
				break;
			case 20:
				{
				alt8=4;
				}
				break;
			default:
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae =
					new NoViableAltException("", 8, 0, input);
				throw nvae;
			}
			switch (alt8) {
				case 1 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:87:13: number
					{
					root_0 = (CommonTree)adaptor.nil();


					pushFollow(FOLLOW_number_in_expr31049);
					number67=number();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, number67.getTree());

					}
					break;
				case 2 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:87:22: '-' number
					{
					root_0 = (CommonTree)adaptor.nil();


					char_literal68=(Token)match(input,24,FOLLOW_24_in_expr31053); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal68_tree = (CommonTree)adaptor.create(char_literal68);
					adaptor.addChild(root_0, char_literal68_tree);
					}

					pushFollow(FOLLOW_number_in_expr31055);
					number69=number();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) adaptor.addChild(root_0, number69.getTree());

					}
					break;
				case 3 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:87:35: STRINGCONST
					{
					root_0 = (CommonTree)adaptor.nil();


					STRINGCONST70=(Token)match(input,STRINGCONST,FOLLOW_STRINGCONST_in_expr31059); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					STRINGCONST70_tree = (CommonTree)adaptor.create(STRINGCONST70);
					adaptor.addChild(root_0, STRINGCONST70_tree);
					}

					}
					break;
				case 4 :
					// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:87:49: '(' ! expr ^ ')'
					{
					root_0 = (CommonTree)adaptor.nil();


					char_literal71=(Token)match(input,20,FOLLOW_20_in_expr31063); if (state.failed) return retval;
					pushFollow(FOLLOW_expr_in_expr31066);
					expr72=expr();
					state._fsp--;
					if (state.failed) return retval;
					if ( state.backtracking==0 ) root_0 = (CommonTree)adaptor.becomeRoot(expr72.getTree(), root_0);
					char_literal73=(Token)match(input,21,FOLLOW_21_in_expr31069); if (state.failed) return retval;
					if ( state.backtracking==0 ) {
					char_literal73_tree = (CommonTree)adaptor.create(char_literal73);
					adaptor.addChild(root_0, char_literal73_tree);
					}

					}
					break;

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

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


	public static class number_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "number"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:88:1: number : ( INTCONST | FLOATCONST );
	public final XParser.number_return number() throws RecognitionException {
		XParser.number_return retval = new XParser.number_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token set74=null;

		CommonTree set74_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:88:7: ( INTCONST | FLOATCONST )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:
			{
			root_0 = (CommonTree)adaptor.nil();


			set74=input.LT(1);
			if ( input.LA(1)==FLOATCONST||input.LA(1)==INTCONST ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set74));
				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 = (CommonTree)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "number"


	public static class compOp_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "compOp"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:90:1: compOp : ( '<' | '>' | '=' );
	public final XParser.compOp_return compOp() throws RecognitionException {
		XParser.compOp_return retval = new XParser.compOp_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token set75=null;

		CommonTree set75_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:90:7: ( '<' | '>' | '=' )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:
			{
			root_0 = (CommonTree)adaptor.nil();


			set75=input.LT(1);
			if ( (input.LA(1) >= 30 && input.LA(1) <= 32) ) {
				input.consume();
				if ( state.backtracking==0 ) adaptor.addChild(root_0, (CommonTree)adaptor.create(set75));
				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 = (CommonTree)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
			}
		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
	// $ANTLR end "compOp"


	public static class cond_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "cond"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:91:1: cond : expr cond2 ;
	public final XParser.cond_return cond() throws RecognitionException {
		XParser.cond_return retval = new XParser.cond_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		ParserRuleReturnScope expr76 =null;
		ParserRuleReturnScope cond277 =null;


		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:91:5: ( expr cond2 )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:91:13: expr cond2
			{
			root_0 = (CommonTree)adaptor.nil();


			pushFollow(FOLLOW_expr_in_cond1114);
			expr76=expr();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, expr76.getTree());

			pushFollow(FOLLOW_cond2_in_cond1116);
			cond277=cond2();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, cond277.getTree());

			}

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

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


	public static class cond2_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "cond2"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:92:1: cond2 : compOp expr ;
	public final XParser.cond2_return cond2() throws RecognitionException {
		XParser.cond2_return retval = new XParser.cond2_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		ParserRuleReturnScope compOp78 =null;
		ParserRuleReturnScope expr79 =null;


		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:92:6: ( compOp expr )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:92:13: compOp expr
			{
			root_0 = (CommonTree)adaptor.nil();


			pushFollow(FOLLOW_compOp_in_cond21127);
			compOp78=compOp();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, compOp78.getTree());

			pushFollow(FOLLOW_expr_in_cond21129);
			expr79=expr();
			state._fsp--;
			if (state.failed) return retval;
			if ( state.backtracking==0 ) adaptor.addChild(root_0, expr79.getTree());

			}

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

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


	public static class minus_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "minus"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:97:1: minus : '-' ;
	public final XParser.minus_return minus() throws RecognitionException {
		XParser.minus_return retval = new XParser.minus_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token char_literal80=null;

		CommonTree char_literal80_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:97:6: ( '-' )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:97:13: '-'
			{
			root_0 = (CommonTree)adaptor.nil();


			char_literal80=(Token)match(input,24,FOLLOW_24_in_minus1144); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal80_tree = (CommonTree)adaptor.create(char_literal80);
			adaptor.addChild(root_0, char_literal80_tree);
			}

			}

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

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


	public static class div_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "div"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:98:1: div : '/' ;
	public final XParser.div_return div() throws RecognitionException {
		XParser.div_return retval = new XParser.div_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token char_literal81=null;

		CommonTree char_literal81_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:98:4: ( '/' )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:98:11: '/'
			{
			root_0 = (CommonTree)adaptor.nil();


			char_literal81=(Token)match(input,26,FOLLOW_26_in_div1155); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal81_tree = (CommonTree)adaptor.create(char_literal81);
			adaptor.addChild(root_0, char_literal81_tree);
			}

			}

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

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


	public static class multiply_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "multiply"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:99:1: multiply : '*' ;
	public final XParser.multiply_return multiply() throws RecognitionException {
		XParser.multiply_return retval = new XParser.multiply_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token char_literal82=null;

		CommonTree char_literal82_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:99:9: ( '*' )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:99:16: '*'
			{
			root_0 = (CommonTree)adaptor.nil();


			char_literal82=(Token)match(input,22,FOLLOW_22_in_multiply1166); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal82_tree = (CommonTree)adaptor.create(char_literal82);
			adaptor.addChild(root_0, char_literal82_tree);
			}

			}

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

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


	public static class plus_return extends ParserRuleReturnScope {
		CommonTree tree;
		@Override
		public CommonTree getTree() { return tree; }
	};


	// $ANTLR start "plus"
	// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:100:1: plus : '+' ;
	public final XParser.plus_return plus() throws RecognitionException {
		XParser.plus_return retval = new XParser.plus_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token char_literal83=null;

		CommonTree char_literal83_tree=null;

		try {
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:100:5: ( '+' )
			// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:100:13: '+'
			{
			root_0 = (CommonTree)adaptor.nil();


			char_literal83=(Token)match(input,23,FOLLOW_23_in_plus1178); if (state.failed) return retval;
			if ( state.backtracking==0 ) {
			char_literal83_tree = (CommonTree)adaptor.create(char_literal83);
			adaptor.addChild(root_0, char_literal83_tree);
			}

			}

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

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

	// $ANTLR start synpred2_X
	public final void synpred2_X_fragment() throws RecognitionException {
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:17: ( 'read' ( 'print' )? )
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:17: 'read' ( 'print' )?
		{
		match(input,42,FOLLOW_42_in_synpred2_X571); if (state.failed) return;

		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:24: ( 'print' )?
		int alt9=2;
		int LA9_0 = input.LA(1);
		if ( (LA9_0==40) ) {
			alt9=1;
		}
		switch (alt9) {
			case 1 :
				// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:24: 'print'
				{
				match(input,40,FOLLOW_40_in_synpred2_X573); if (state.failed) return;

				}
				break;

		}

		}

	}
	// $ANTLR end synpred2_X

	// $ANTLR start synpred3_X
	public final void synpred3_X_fragment() throws RecognitionException {
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:35: ( 'read' )
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:68:35: 'read'
		{
		match(input,42,FOLLOW_42_in_synpred3_X578); if (state.failed) return;

		}

	}
	// $ANTLR end synpred3_X

	// $ANTLR start synpred11_X
	public final void synpred11_X_fragment() throws RecognitionException {
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:39: ( condElseStat )
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:75:39: condElseStat
		{
		pushFollow(FOLLOW_condElseStat_in_synpred11_X714);
		condElseStat();
		state._fsp--;
		if (state.failed) return;

		}

	}
	// $ANTLR end synpred11_X

	// $ANTLR start synpred12_X
	public final void synpred12_X_fragment() throws RecognitionException {
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:81:13: ( expr2 '+' expr )
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:81:13: expr2 '+' expr
		{
		pushFollow(FOLLOW_expr2_in_synpred12_X848);
		expr2();
		state._fsp--;
		if (state.failed) return;

		match(input,23,FOLLOW_23_in_synpred12_X850); if (state.failed) return;

		pushFollow(FOLLOW_expr_in_synpred12_X852);
		expr();
		state._fsp--;
		if (state.failed) return;

		}

	}
	// $ANTLR end synpred12_X

	// $ANTLR start synpred13_X
	public final void synpred13_X_fragment() throws RecognitionException {
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:82:15: ( expr2 '-' expr )
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:82:15: expr2 '-' expr
		{
		pushFollow(FOLLOW_expr2_in_synpred13_X885);
		expr2();
		state._fsp--;
		if (state.failed) return;

		match(input,24,FOLLOW_24_in_synpred13_X887); if (state.failed) return;

		pushFollow(FOLLOW_expr_in_synpred13_X889);
		expr();
		state._fsp--;
		if (state.failed) return;

		}

	}
	// $ANTLR end synpred13_X

	// $ANTLR start synpred14_X
	public final void synpred14_X_fragment() throws RecognitionException {
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:84:13: ( expr3 '*' expr2 )
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:84:13: expr3 '*' expr2
		{
		pushFollow(FOLLOW_expr3_in_synpred14_X952);
		expr3();
		state._fsp--;
		if (state.failed) return;

		match(input,22,FOLLOW_22_in_synpred14_X954); if (state.failed) return;

		pushFollow(FOLLOW_expr2_in_synpred14_X956);
		expr2();
		state._fsp--;
		if (state.failed) return;

		}

	}
	// $ANTLR end synpred14_X

	// $ANTLR start synpred15_X
	public final void synpred15_X_fragment() throws RecognitionException {
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:85:15: ( expr3 '/' expr2 )
		// C:\\Development\\Schule\\Compilerbau\\CC-Praxis-Antlr Parser fuer X-Leer\\src/de/dhbw/compiler/antlrxparser/X.g:85:15: expr3 '/' expr2
		{
		pushFollow(FOLLOW_expr3_in_synpred15_X984);
		expr3();
		state._fsp--;
		if (state.failed) return;

		match(input,26,FOLLOW_26_in_synpred15_X986); if (state.failed) return;

		pushFollow(FOLLOW_expr2_in_synpred15_X988);
		expr2();
		state._fsp--;
		if (state.failed) return;

		}

	}
	// $ANTLR end synpred15_X

	// Delegated rules

	public final boolean synpred15_X() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred15_X_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;
	}
	public final boolean synpred13_X() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred13_X_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;
	}
	public final boolean synpred14_X() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred14_X_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;
	}
	public final boolean synpred3_X() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred3_X_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;
	}
	public final boolean synpred11_X() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred11_X_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;
	}
	public final boolean synpred2_X() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred2_X_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;
	}
	public final boolean synpred12_X() {
		state.backtracking++;
		int start = input.mark();
		try {
			synpred12_X_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;
	}



	public static final BitSet FOLLOW_41_in_program473 = new BitSet(new long[]{0x0000000000000400L});
	public static final BitSet FOLLOW_ID_in_program475 = new BitSet(new long[]{0x0000000020000000L});
	public static final BitSet FOLLOW_29_in_program477 = new BitSet(new long[]{0x0000050000000000L});
	public static final BitSet FOLLOW_decllist_in_program479 = new BitSet(new long[]{0x0000000200000000L});
	public static final BitSet FOLLOW_statlist_in_program481 = new BitSet(new long[]{0x0000000002000000L});
	public static final BitSet FOLLOW_25_in_program483 = new BitSet(new long[]{0x0000000000000000L});
	public static final BitSet FOLLOW_EOF_in_program485 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_decl_in_decllist511 = new BitSet(new long[]{0x0000050000000000L});
	public static final BitSet FOLLOW_decllist_in_decllist513 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_modifier_in_decl539 = new BitSet(new long[]{0x0000000000000400L});
	public static final BitSet FOLLOW_ID_in_decl541 = new BitSet(new long[]{0x0000000008000000L});
	public static final BitSet FOLLOW_27_in_decl543 = new BitSet(new long[]{0x0000089000000000L});
	public static final BitSet FOLLOW_type_in_decl545 = new BitSet(new long[]{0x0000000020000000L});
	public static final BitSet FOLLOW_29_in_decl547 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_42_in_modifier571 = new BitSet(new long[]{0x0000010000000002L});
	public static final BitSet FOLLOW_40_in_modifier573 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_42_in_modifier578 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_40_in_modifier582 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_33_in_statlist620 = new BitSet(new long[]{0x0000206A00000400L});
	public static final BitSet FOLLOW_stat_in_statlist623 = new BitSet(new long[]{0x0000000020000000L});
	public static final BitSet FOLLOW_29_in_statlist625 = new BitSet(new long[]{0x0000206A00000400L});
	public static final BitSet FOLLOW_35_in_statlist629 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_assignstat_in_stat654 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_condstat_in_stat658 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_whilestat_in_stat662 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_forstat_in_stat666 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_statlist_in_stat670 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_ID_in_assignstat680 = new BitSet(new long[]{0x0000000010000000L});
	public static final BitSet FOLLOW_28_in_assignstat682 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr_in_assignstat684 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_38_in_condstat706 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_cond_in_condstat708 = new BitSet(new long[]{0x0000100000000000L});
	public static final BitSet FOLLOW_44_in_condstat710 = new BitSet(new long[]{0x0000206200000400L});
	public static final BitSet FOLLOW_stat_in_condstat712 = new BitSet(new long[]{0x0000000400000002L});
	public static final BitSet FOLLOW_condElseStat_in_condstat714 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_34_in_condElseStat737 = new BitSet(new long[]{0x0000206200000400L});
	public static final BitSet FOLLOW_stat_in_condElseStat739 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_45_in_whilestat758 = new BitSet(new long[]{0x0000000000100000L});
	public static final BitSet FOLLOW_20_in_whilestat760 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_cond_in_whilestat762 = new BitSet(new long[]{0x0000000000200000L});
	public static final BitSet FOLLOW_21_in_whilestat764 = new BitSet(new long[]{0x0000206200000400L});
	public static final BitSet FOLLOW_stat_in_whilestat766 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_37_in_forstat789 = new BitSet(new long[]{0x0000000000100000L});
	public static final BitSet FOLLOW_20_in_forstat791 = new BitSet(new long[]{0x0000000000000400L});
	public static final BitSet FOLLOW_assignstat_in_forstat793 = new BitSet(new long[]{0x0000000020000000L});
	public static final BitSet FOLLOW_29_in_forstat795 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_cond_in_forstat797 = new BitSet(new long[]{0x0000000020000000L});
	public static final BitSet FOLLOW_29_in_forstat799 = new BitSet(new long[]{0x0000000000000400L});
	public static final BitSet FOLLOW_assignstat_in_forstat801 = new BitSet(new long[]{0x0000000000200000L});
	public static final BitSet FOLLOW_21_in_forstat803 = new BitSet(new long[]{0x0000206200000400L});
	public static final BitSet FOLLOW_stat_in_forstat805 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr2_in_expr848 = new BitSet(new long[]{0x0000000000800000L});
	public static final BitSet FOLLOW_23_in_expr850 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr_in_expr852 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr2_in_expr885 = new BitSet(new long[]{0x0000000001000000L});
	public static final BitSet FOLLOW_24_in_expr887 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr_in_expr889 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr2_in_expr919 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr3_in_expr2952 = new BitSet(new long[]{0x0000000000400000L});
	public static final BitSet FOLLOW_22_in_expr2954 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr2_in_expr2956 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr3_in_expr2984 = new BitSet(new long[]{0x0000000004000000L});
	public static final BitSet FOLLOW_26_in_expr2986 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr2_in_expr2988 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr3_in_expr21016 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_number_in_expr31049 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_24_in_expr31053 = new BitSet(new long[]{0x0000000000000A00L});
	public static final BitSet FOLLOW_number_in_expr31055 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_STRINGCONST_in_expr31059 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_20_in_expr31063 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr_in_expr31066 = new BitSet(new long[]{0x0000000000200000L});
	public static final BitSet FOLLOW_21_in_expr31069 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr_in_cond1114 = new BitSet(new long[]{0x00000001C0000000L});
	public static final BitSet FOLLOW_cond2_in_cond1116 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_compOp_in_cond21127 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr_in_cond21129 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_24_in_minus1144 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_26_in_div1155 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_22_in_multiply1166 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_23_in_plus1178 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_42_in_synpred2_X571 = new BitSet(new long[]{0x0000010000000002L});
	public static final BitSet FOLLOW_40_in_synpred2_X573 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_42_in_synpred3_X578 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_condElseStat_in_synpred11_X714 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr2_in_synpred12_X848 = new BitSet(new long[]{0x0000000000800000L});
	public static final BitSet FOLLOW_23_in_synpred12_X850 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr_in_synpred12_X852 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr2_in_synpred13_X885 = new BitSet(new long[]{0x0000000001000000L});
	public static final BitSet FOLLOW_24_in_synpred13_X887 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr_in_synpred13_X889 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr3_in_synpred14_X952 = new BitSet(new long[]{0x0000000000400000L});
	public static final BitSet FOLLOW_22_in_synpred14_X954 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr2_in_synpred14_X956 = new BitSet(new long[]{0x0000000000000002L});
	public static final BitSet FOLLOW_expr3_in_synpred15_X984 = new BitSet(new long[]{0x0000000004000000L});
	public static final BitSet FOLLOW_26_in_synpred15_X986 = new BitSet(new long[]{0x0000000001120A00L});
	public static final BitSet FOLLOW_expr2_in_synpred15_X988 = new BitSet(new long[]{0x0000000000000002L});
}
