InitParsetreeConstructor.java

/*
* generated by Xtext
*/
package org.kermeta.language.sample.cellularautomata.rules.parseTreeConstruction;

import org.eclipse.emf.ecore.*;
import org.eclipse.xtext.*;
import org.eclipse.xtext.parsetree.reconstr.IEObjectConsumer;
import org.eclipse.xtext.parsetree.reconstr.impl.AbstractParseTreeConstructor;

import org.kermeta.language.sample.cellularautomata.rules.services.InitGrammarAccess;

import com.google.inject.Inject;

@SuppressWarnings("all")
public class InitParsetreeConstructor extends AbstractParseTreeConstructor {
		
	@Inject
	private InitGrammarAccess grammarAccess;
	
	@Override
	protected AbstractToken getRootToken(IEObjectConsumer inst) {
		return new ThisRootNode(inst);	
	}
	
protected class ThisRootNode extends RootToken {
	public ThisRootNode(IEObjectConsumer inst) {
		super(inst);
	}
	
	@Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CellularAutomataInitialization_Group(this, this, 0, inst);
			case 1: return new Rule_Group(this, this, 1, inst);
			case 2: return new GlobalPosition_Group(this, this, 2, inst);
			case 3: return new CoordinateRange_Group(this, this, 3, inst);
			case 4: return new LiteralsExpression_Alternatives(this, this, 4, inst);
			case 5: return new PositionLiteral_Group(this, this, 5, inst);
			case 6: return new RegularGeometry_Group(this, this, 6, inst);
			case 7: return new Dimension_Alternatives(this, this, 7, inst);
			case 8: return new Conditional_Alternatives(this, this, 8, inst);
			case 9: return new OrExpression_Group(this, this, 9, inst);
			case 10: return new AndExpression_Group(this, this, 10, inst);
			case 11: return new EqualExpression_Group(this, this, 11, inst);
			case 12: return new ComparisonExpression_Group(this, this, 12, inst);
			case 13: return new AddExpression_Group(this, this, 13, inst);
			case 14: return new MultExpression_Group(this, this, 14, inst);
			case 15: return new UnaryExpression_Alternatives(this, this, 15, inst);
			case 16: return new IntegerLiteral_ValAssignment(this, this, 16, inst);
			default: return null;
		}	
	}	
}
	

/************ begin Rule CellularAutomataInitialization ****************
 *
 * / **
 * 
 *  * Root for Init
 * 
 *  * / CellularAutomataInitialization returns CellularAutomatatInitialization:
 * 
 * 	{CellularAutomatatInitialization} geometry=RegularGeometry? seedRules+=Rule seedRules+=Rule*;
 *
 **/

// {CellularAutomatatInitialization} geometry=RegularGeometry? seedRules+=Rule seedRules+=Rule*
protected class CellularAutomataInitialization_Group extends GroupToken {
	
	public CellularAutomataInitialization_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getCellularAutomataInitializationAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CellularAutomataInitialization_SeedRulesAssignment_3(lastRuleCallOrigin, this, 0, inst);
			case 1: return new CellularAutomataInitialization_SeedRulesAssignment_2(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getCellularAutomataInitializationAccess().getCellularAutomatatInitializationAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {CellularAutomatatInitialization}
protected class CellularAutomataInitialization_CellularAutomatatInitializationAction_0 extends ActionToken  {

	public CellularAutomataInitialization_CellularAutomatatInitializationAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getCellularAutomataInitializationAccess().getCellularAutomatatInitializationAction_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// geometry=RegularGeometry?
protected class CellularAutomataInitialization_GeometryAssignment_1 extends AssignmentToken  {
	
	public CellularAutomataInitialization_GeometryAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getCellularAutomataInitializationAccess().getGeometryAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RegularGeometry_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("geometry",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("geometry");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getRegularGeometryRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getCellularAutomataInitializationAccess().getGeometryRegularGeometryParserRuleCall_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new CellularAutomataInitialization_CellularAutomatatInitializationAction_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// seedRules+=Rule
protected class CellularAutomataInitialization_SeedRulesAssignment_2 extends AssignmentToken  {
	
	public CellularAutomataInitialization_SeedRulesAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getCellularAutomataInitializationAccess().getSeedRulesAssignment_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Rule_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("seedRules",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("seedRules");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getRuleRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getCellularAutomataInitializationAccess().getSeedRulesRuleParserRuleCall_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new CellularAutomataInitialization_GeometryAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new CellularAutomataInitialization_CellularAutomatatInitializationAction_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// seedRules+=Rule*
protected class CellularAutomataInitialization_SeedRulesAssignment_3 extends AssignmentToken  {
	
	public CellularAutomataInitialization_SeedRulesAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getCellularAutomataInitializationAccess().getSeedRulesAssignment_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Rule_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("seedRules",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("seedRules");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getRuleRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getCellularAutomataInitializationAccess().getSeedRulesRuleParserRuleCall_3_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new CellularAutomataInitialization_SeedRulesAssignment_3(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new CellularAutomataInitialization_SeedRulesAssignment_2(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


/************ end Rule CellularAutomataInitialization ****************/


/************ begin Rule Rule ****************
 *
 * / **
 * 
 *  * From Init
 * 
 *  * / Rule returns core::Rule:
 * 
 * 	"where" filter=GlobalPosition? "initValue" "=" "{" evaluatedVal=Conditional "}";
 *
 **/

// "where" filter=GlobalPosition? "initValue" "=" "{" evaluatedVal=Conditional "}"
protected class Rule_Group extends GroupToken {
	
	public Rule_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getRuleAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Rule_RightCurlyBracketKeyword_6(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getRuleRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "where"
protected class Rule_WhereKeyword_0 extends KeywordToken  {
	
	public Rule_WhereKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRuleAccess().getWhereKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// filter=GlobalPosition?
protected class Rule_FilterAssignment_1 extends AssignmentToken  {
	
	public Rule_FilterAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getRuleAccess().getFilterAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GlobalPosition_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("filter",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("filter");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getGlobalPositionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getRuleAccess().getFilterGlobalPositionParserRuleCall_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Rule_WhereKeyword_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// "initValue"
protected class Rule_InitValueKeyword_2 extends KeywordToken  {
	
	public Rule_InitValueKeyword_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRuleAccess().getInitValueKeyword_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Rule_FilterAssignment_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Rule_WhereKeyword_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// "="
protected class Rule_EqualsSignKeyword_3 extends KeywordToken  {
	
	public Rule_EqualsSignKeyword_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRuleAccess().getEqualsSignKeyword_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Rule_InitValueKeyword_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "{"
protected class Rule_LeftCurlyBracketKeyword_4 extends KeywordToken  {
	
	public Rule_LeftCurlyBracketKeyword_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRuleAccess().getLeftCurlyBracketKeyword_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Rule_EqualsSignKeyword_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// evaluatedVal=Conditional
protected class Rule_EvaluatedValAssignment_5 extends AssignmentToken  {
	
	public Rule_EvaluatedValAssignment_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getRuleAccess().getEvaluatedValAssignment_5();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("evaluatedVal",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("evaluatedVal");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getConditionalRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getRuleAccess().getEvaluatedValConditionalParserRuleCall_5_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Rule_LeftCurlyBracketKeyword_4(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// "}"
protected class Rule_RightCurlyBracketKeyword_6 extends KeywordToken  {
	
	public Rule_RightCurlyBracketKeyword_6(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRuleAccess().getRightCurlyBracketKeyword_6();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Rule_EvaluatedValAssignment_5(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule Rule ****************/


/************ begin Rule GlobalPosition ****************
 *
 * GlobalPosition:
 * 
 * 	{GlobalPosition} "{" coordinateRanges+=CoordinateRange ("x" coordinateRanges+=CoordinateRange?)* "}";
 *
 **/

// {GlobalPosition} "{" coordinateRanges+=CoordinateRange ("x" coordinateRanges+=CoordinateRange?)* "}"
protected class GlobalPosition_Group extends GroupToken {
	
	public GlobalPosition_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGlobalPositionAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GlobalPosition_RightCurlyBracketKeyword_4(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getGlobalPositionAccess().getGlobalPositionAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {GlobalPosition}
protected class GlobalPosition_GlobalPositionAction_0 extends ActionToken  {

	public GlobalPosition_GlobalPositionAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getGlobalPositionAccess().getGlobalPositionAction_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// "{"
protected class GlobalPosition_LeftCurlyBracketKeyword_1 extends KeywordToken  {
	
	public GlobalPosition_LeftCurlyBracketKeyword_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGlobalPositionAccess().getLeftCurlyBracketKeyword_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GlobalPosition_GlobalPositionAction_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// coordinateRanges+=CoordinateRange
protected class GlobalPosition_CoordinateRangesAssignment_2 extends AssignmentToken  {
	
	public GlobalPosition_CoordinateRangesAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGlobalPositionAccess().getCoordinateRangesAssignment_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CoordinateRange_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("coordinateRanges",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("coordinateRanges");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getCoordinateRangeRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getGlobalPositionAccess().getCoordinateRangesCoordinateRangeParserRuleCall_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new GlobalPosition_LeftCurlyBracketKeyword_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// ("x" coordinateRanges+=CoordinateRange?)*
protected class GlobalPosition_Group_3 extends GroupToken {
	
	public GlobalPosition_Group_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getGlobalPositionAccess().getGroup_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GlobalPosition_CoordinateRangesAssignment_3_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "x"
protected class GlobalPosition_XKeyword_3_0 extends KeywordToken  {
	
	public GlobalPosition_XKeyword_3_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGlobalPositionAccess().getXKeyword_3_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GlobalPosition_Group_3(lastRuleCallOrigin, this, 0, inst);
			case 1: return new GlobalPosition_CoordinateRangesAssignment_2(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// coordinateRanges+=CoordinateRange?
protected class GlobalPosition_CoordinateRangesAssignment_3_1 extends AssignmentToken  {
	
	public GlobalPosition_CoordinateRangesAssignment_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getGlobalPositionAccess().getCoordinateRangesAssignment_3_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CoordinateRange_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("coordinateRanges",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("coordinateRanges");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getCoordinateRangeRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getGlobalPositionAccess().getCoordinateRangesCoordinateRangeParserRuleCall_3_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new GlobalPosition_XKeyword_3_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// "}"
protected class GlobalPosition_RightCurlyBracketKeyword_4 extends KeywordToken  {
	
	public GlobalPosition_RightCurlyBracketKeyword_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getGlobalPositionAccess().getRightCurlyBracketKeyword_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new GlobalPosition_Group_3(lastRuleCallOrigin, this, 0, inst);
			case 1: return new GlobalPosition_CoordinateRangesAssignment_2(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}


/************ end Rule GlobalPosition ****************/


/************ begin Rule CoordinateRange ****************
 *
 * CoordinateRange:
 * 
 * 	"[" lowerCoordinate=EInt "," upperCoordinate=EInt "]";
 *
 **/

// "[" lowerCoordinate=EInt "," upperCoordinate=EInt "]"
protected class CoordinateRange_Group extends GroupToken {
	
	public CoordinateRange_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getCoordinateRangeAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CoordinateRange_RightSquareBracketKeyword_4(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getCoordinateRangeRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "["
protected class CoordinateRange_LeftSquareBracketKeyword_0 extends KeywordToken  {
	
	public CoordinateRange_LeftSquareBracketKeyword_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getCoordinateRangeAccess().getLeftSquareBracketKeyword_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// lowerCoordinate=EInt
protected class CoordinateRange_LowerCoordinateAssignment_1 extends AssignmentToken  {
	
	public CoordinateRange_LowerCoordinateAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getCoordinateRangeAccess().getLowerCoordinateAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CoordinateRange_LeftSquareBracketKeyword_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("lowerCoordinate",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("lowerCoordinate");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getCoordinateRangeAccess().getLowerCoordinateEIntParserRuleCall_1_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getCoordinateRangeAccess().getLowerCoordinateEIntParserRuleCall_1_0();
			return obj;
		}
		return null;
	}

}

// ","
protected class CoordinateRange_CommaKeyword_2 extends KeywordToken  {
	
	public CoordinateRange_CommaKeyword_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getCoordinateRangeAccess().getCommaKeyword_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CoordinateRange_LowerCoordinateAssignment_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// upperCoordinate=EInt
protected class CoordinateRange_UpperCoordinateAssignment_3 extends AssignmentToken  {
	
	public CoordinateRange_UpperCoordinateAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getCoordinateRangeAccess().getUpperCoordinateAssignment_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CoordinateRange_CommaKeyword_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("upperCoordinate",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("upperCoordinate");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getCoordinateRangeAccess().getUpperCoordinateEIntParserRuleCall_3_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getCoordinateRangeAccess().getUpperCoordinateEIntParserRuleCall_3_0();
			return obj;
		}
		return null;
	}

}

// "]"
protected class CoordinateRange_RightSquareBracketKeyword_4 extends KeywordToken  {
	
	public CoordinateRange_RightSquareBracketKeyword_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getCoordinateRangeAccess().getRightSquareBracketKeyword_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new CoordinateRange_UpperCoordinateAssignment_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule CoordinateRange ****************/


/************ begin Rule LiteralsExpression ****************
 *
 * LiteralsExpression returns core::IntegerExpression:
 * 
 * 	"(" Conditional ")" | PositionLiteral | IntegerLiteral;
 *
 **/

// "(" Conditional ")" | PositionLiteral | IntegerLiteral
protected class LiteralsExpression_Alternatives extends AlternativesToken {

	public LiteralsExpression_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getLiteralsExpressionAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new LiteralsExpression_Group_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new LiteralsExpression_PositionLiteralParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new LiteralsExpression_IntegerLiteralParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// "(" Conditional ")"
protected class LiteralsExpression_Group_0 extends GroupToken {
	
	public LiteralsExpression_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getLiteralsExpressionAccess().getGroup_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new LiteralsExpression_RightParenthesisKeyword_0_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "("
protected class LiteralsExpression_LeftParenthesisKeyword_0_0 extends KeywordToken  {
	
	public LiteralsExpression_LeftParenthesisKeyword_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getLiteralsExpressionAccess().getLeftParenthesisKeyword_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

}

// Conditional
protected class LiteralsExpression_ConditionalParserRuleCall_0_1 extends RuleCallToken {
	
	public LiteralsExpression_ConditionalParserRuleCall_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralsExpressionAccess().getConditionalParserRuleCall_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(Conditional_Alternatives.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new LiteralsExpression_LeftParenthesisKeyword_0_0(lastRuleCallOrigin, next, actIndex, inst);
			default: return null;
		}	
	}	
}

// ")"
protected class LiteralsExpression_RightParenthesisKeyword_0_2 extends KeywordToken  {
	
	public LiteralsExpression_RightParenthesisKeyword_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getLiteralsExpressionAccess().getRightParenthesisKeyword_0_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new LiteralsExpression_ConditionalParserRuleCall_0_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


// PositionLiteral
protected class LiteralsExpression_PositionLiteralParserRuleCall_1 extends RuleCallToken {
	
	public LiteralsExpression_PositionLiteralParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralsExpressionAccess().getPositionLiteralParserRuleCall_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PositionLiteral_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier())
			return null;
		if(checkForRecursion(PositionLiteral_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// IntegerLiteral
protected class LiteralsExpression_IntegerLiteralParserRuleCall_2 extends RuleCallToken {
	
	public LiteralsExpression_IntegerLiteralParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralsExpressionAccess().getIntegerLiteralParserRuleCall_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new IntegerLiteral_ValAssignment(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(IntegerLiteral_ValAssignment.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}


/************ end Rule LiteralsExpression ****************/


/************ begin Rule PositionLiteral ****************
 *
 * PositionLiteral returns core::IntegerExpression:
 * 
 * 	{PositionLiteral} "positionOn" "[" dimensionIndex=EInt "]";
 *
 **/

// {PositionLiteral} "positionOn" "[" dimensionIndex=EInt "]"
protected class PositionLiteral_Group extends GroupToken {
	
	public PositionLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getPositionLiteralAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PositionLiteral_RightSquareBracketKeyword_4(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {PositionLiteral}
protected class PositionLiteral_PositionLiteralAction_0 extends ActionToken  {

	public PositionLiteral_PositionLiteralAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// "positionOn"
protected class PositionLiteral_PositionOnKeyword_1 extends KeywordToken  {
	
	public PositionLiteral_PositionOnKeyword_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getPositionLiteralAccess().getPositionOnKeyword_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PositionLiteral_PositionLiteralAction_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "["
protected class PositionLiteral_LeftSquareBracketKeyword_2 extends KeywordToken  {
	
	public PositionLiteral_LeftSquareBracketKeyword_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getPositionLiteralAccess().getLeftSquareBracketKeyword_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PositionLiteral_PositionOnKeyword_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// dimensionIndex=EInt
protected class PositionLiteral_DimensionIndexAssignment_3 extends AssignmentToken  {
	
	public PositionLiteral_DimensionIndexAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getPositionLiteralAccess().getDimensionIndexAssignment_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PositionLiteral_LeftSquareBracketKeyword_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("dimensionIndex",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dimensionIndex");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getPositionLiteralAccess().getDimensionIndexEIntParserRuleCall_3_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getPositionLiteralAccess().getDimensionIndexEIntParserRuleCall_3_0();
			return obj;
		}
		return null;
	}

}

// "]"
protected class PositionLiteral_RightSquareBracketKeyword_4 extends KeywordToken  {
	
	public PositionLiteral_RightSquareBracketKeyword_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getPositionLiteralAccess().getRightSquareBracketKeyword_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new PositionLiteral_DimensionIndexAssignment_3(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


/************ end Rule PositionLiteral ****************/


/************ begin Rule RegularGeometry ****************
 *
 * / **
 * 
 *  * From Geometry
 * 
 *  * / RegularGeometry:
 * 
 * 	{RegularGeometry} "regularGeometry" neighborsNumber=EInt "{" dimensions+=Dimension ("x" dimensions+=Dimension)* "}";
 *
 **/

// {RegularGeometry} "regularGeometry" neighborsNumber=EInt "{" dimensions+=Dimension ("x" dimensions+=Dimension)* "}"
protected class RegularGeometry_Group extends GroupToken {
	
	public RegularGeometry_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RegularGeometry_RightCurlyBracketKeyword_6(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getRegularGeometryAccess().getRegularGeometryAction_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {RegularGeometry}
protected class RegularGeometry_RegularGeometryAction_0 extends ActionToken  {

	public RegularGeometry_RegularGeometryAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getRegularGeometryAction_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// "regularGeometry"
protected class RegularGeometry_RegularGeometryKeyword_1 extends KeywordToken  {
	
	public RegularGeometry_RegularGeometryKeyword_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getRegularGeometryKeyword_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RegularGeometry_RegularGeometryAction_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// neighborsNumber=EInt
protected class RegularGeometry_NeighborsNumberAssignment_2 extends AssignmentToken  {
	
	public RegularGeometry_NeighborsNumberAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getNeighborsNumberAssignment_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RegularGeometry_RegularGeometryKeyword_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("neighborsNumber",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("neighborsNumber");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getRegularGeometryAccess().getNeighborsNumberEIntParserRuleCall_2_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getRegularGeometryAccess().getNeighborsNumberEIntParserRuleCall_2_0();
			return obj;
		}
		return null;
	}

}

// "{"
protected class RegularGeometry_LeftCurlyBracketKeyword_3 extends KeywordToken  {
	
	public RegularGeometry_LeftCurlyBracketKeyword_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getLeftCurlyBracketKeyword_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RegularGeometry_NeighborsNumberAssignment_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// dimensions+=Dimension
protected class RegularGeometry_DimensionsAssignment_4 extends AssignmentToken  {
	
	public RegularGeometry_DimensionsAssignment_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getDimensionsAssignment_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Dimension_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("dimensions",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dimensions");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getDimensionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getRegularGeometryAccess().getDimensionsDimensionParserRuleCall_4_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new RegularGeometry_LeftCurlyBracketKeyword_3(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// ("x" dimensions+=Dimension)*
protected class RegularGeometry_Group_5 extends GroupToken {
	
	public RegularGeometry_Group_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getGroup_5();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RegularGeometry_DimensionsAssignment_5_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "x"
protected class RegularGeometry_XKeyword_5_0 extends KeywordToken  {
	
	public RegularGeometry_XKeyword_5_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getXKeyword_5_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RegularGeometry_Group_5(lastRuleCallOrigin, this, 0, inst);
			case 1: return new RegularGeometry_DimensionsAssignment_4(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// dimensions+=Dimension
protected class RegularGeometry_DimensionsAssignment_5_1 extends AssignmentToken  {
	
	public RegularGeometry_DimensionsAssignment_5_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getDimensionsAssignment_5_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Dimension_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("dimensions",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("dimensions");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getDimensionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getRegularGeometryAccess().getDimensionsDimensionParserRuleCall_5_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new RegularGeometry_XKeyword_5_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// "}"
protected class RegularGeometry_RightCurlyBracketKeyword_6 extends KeywordToken  {
	
	public RegularGeometry_RightCurlyBracketKeyword_6(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getRegularGeometryAccess().getRightCurlyBracketKeyword_6();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new RegularGeometry_Group_5(lastRuleCallOrigin, this, 0, inst);
			case 1: return new RegularGeometry_DimensionsAssignment_4(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}


/************ end Rule RegularGeometry ****************/


/************ begin Rule Dimension ****************
 *
 * Dimension:
 * 
 * 	{Dimension} size=EInt | isCircular?="(" size=EInt ")";
 *
 **/

// {Dimension} size=EInt | isCircular?="(" size=EInt ")"
protected class Dimension_Alternatives extends AlternativesToken {

	public Dimension_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getDimensionAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Dimension_Group_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Dimension_Group_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getDimensionRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Dimension} size=EInt
protected class Dimension_Group_0 extends GroupToken {
	
	public Dimension_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getDimensionAccess().getGroup_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Dimension_SizeAssignment_0_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// {Dimension}
protected class Dimension_DimensionAction_0_0 extends ActionToken  {

	public Dimension_DimensionAction_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getDimensionAccess().getDimensionAction_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// size=EInt
protected class Dimension_SizeAssignment_0_1 extends AssignmentToken  {
	
	public Dimension_SizeAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getDimensionAccess().getSizeAssignment_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Dimension_DimensionAction_0_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("size",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("size");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getDimensionAccess().getSizeEIntParserRuleCall_0_1_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getDimensionAccess().getSizeEIntParserRuleCall_0_1_0();
			return obj;
		}
		return null;
	}

}


// isCircular?="(" size=EInt ")"
protected class Dimension_Group_1 extends GroupToken {
	
	public Dimension_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getDimensionAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Dimension_RightParenthesisKeyword_1_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// isCircular?="("
protected class Dimension_IsCircularAssignment_1_0 extends AssignmentToken  {
	
	public Dimension_IsCircularAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getDimensionAccess().getIsCircularAssignment_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("isCircular",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("isCircular");
		if(Boolean.TRUE.equals(value)) { // org::eclipse::xtext::impl::KeywordImpl
			type = AssignmentType.KEYWORD;
			element = grammarAccess.getDimensionAccess().getIsCircularLeftParenthesisKeyword_1_0_0();
			return obj;
		}
		return null;
	}

}

// size=EInt
protected class Dimension_SizeAssignment_1_1 extends AssignmentToken  {
	
	public Dimension_SizeAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getDimensionAccess().getSizeAssignment_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Dimension_IsCircularAssignment_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("size",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("size");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getDimensionAccess().getSizeEIntParserRuleCall_1_1_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getDimensionAccess().getSizeEIntParserRuleCall_1_1_0();
			return obj;
		}
		return null;
	}

}

// ")"
protected class Dimension_RightParenthesisKeyword_1_2 extends KeywordToken  {
	
	public Dimension_RightParenthesisKeyword_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getDimensionAccess().getRightParenthesisKeyword_1_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Dimension_SizeAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}



/************ end Rule Dimension ****************/


/************ begin Rule Conditional ****************
 *
 * / *
 * 
 *  * Conditional
 * 
 *  * / Conditional returns IntegerExpression:
 * 
 * 	OrExpression | {Conditional} "if" condition=Conditional "{" ifTrueExpression=Conditional "}" "else" "{"
 * 
 * 	ifFalseExpression=Conditional "}";
 *
 **/

// OrExpression | {Conditional} "if" condition=Conditional "{" ifTrueExpression=Conditional "}" "else" "{"
// 
// ifFalseExpression=Conditional "}"
protected class Conditional_Alternatives extends AlternativesToken {

	public Conditional_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getConditionalAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_OrExpressionParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Conditional_Group_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// OrExpression
protected class Conditional_OrExpressionParserRuleCall_0 extends RuleCallToken {
	
	public Conditional_OrExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getConditionalAccess().getOrExpressionParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new OrExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(OrExpression_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// {Conditional} "if" condition=Conditional "{" ifTrueExpression=Conditional "}" "else" "{" ifFalseExpression=Conditional
// 
// "}"
protected class Conditional_Group_1 extends GroupToken {
	
	public Conditional_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getConditionalAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_RightCurlyBracketKeyword_1_9(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Conditional}
protected class Conditional_ConditionalAction_1_0 extends ActionToken  {

	public Conditional_ConditionalAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getConditionalAccess().getConditionalAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// "if"
protected class Conditional_IfKeyword_1_1 extends KeywordToken  {
	
	public Conditional_IfKeyword_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getConditionalAccess().getIfKeyword_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_ConditionalAction_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// condition=Conditional
protected class Conditional_ConditionAssignment_1_2 extends AssignmentToken  {
	
	public Conditional_ConditionAssignment_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getConditionalAccess().getConditionAssignment_1_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("condition",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("condition");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getConditionalRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getConditionalAccess().getConditionConditionalParserRuleCall_1_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Conditional_IfKeyword_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// "{"
protected class Conditional_LeftCurlyBracketKeyword_1_3 extends KeywordToken  {
	
	public Conditional_LeftCurlyBracketKeyword_1_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getConditionalAccess().getLeftCurlyBracketKeyword_1_3();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_ConditionAssignment_1_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// ifTrueExpression=Conditional
protected class Conditional_IfTrueExpressionAssignment_1_4 extends AssignmentToken  {
	
	public Conditional_IfTrueExpressionAssignment_1_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getConditionalAccess().getIfTrueExpressionAssignment_1_4();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("ifTrueExpression",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("ifTrueExpression");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getConditionalRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getConditionalAccess().getIfTrueExpressionConditionalParserRuleCall_1_4_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Conditional_LeftCurlyBracketKeyword_1_3(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// "}"
protected class Conditional_RightCurlyBracketKeyword_1_5 extends KeywordToken  {
	
	public Conditional_RightCurlyBracketKeyword_1_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getConditionalAccess().getRightCurlyBracketKeyword_1_5();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_IfTrueExpressionAssignment_1_4(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "else"
protected class Conditional_ElseKeyword_1_6 extends KeywordToken  {
	
	public Conditional_ElseKeyword_1_6(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getConditionalAccess().getElseKeyword_1_6();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_RightCurlyBracketKeyword_1_5(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// "{"
protected class Conditional_LeftCurlyBracketKeyword_1_7 extends KeywordToken  {
	
	public Conditional_LeftCurlyBracketKeyword_1_7(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getConditionalAccess().getLeftCurlyBracketKeyword_1_7();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_ElseKeyword_1_6(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// ifFalseExpression=Conditional
protected class Conditional_IfFalseExpressionAssignment_1_8 extends AssignmentToken  {
	
	public Conditional_IfFalseExpressionAssignment_1_8(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getConditionalAccess().getIfFalseExpressionAssignment_1_8();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("ifFalseExpression",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("ifFalseExpression");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getConditionalRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getConditionalAccess().getIfFalseExpressionConditionalParserRuleCall_1_8_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new Conditional_LeftCurlyBracketKeyword_1_7(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// "}"
protected class Conditional_RightCurlyBracketKeyword_1_9 extends KeywordToken  {
	
	public Conditional_RightCurlyBracketKeyword_1_9(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getConditionalAccess().getRightCurlyBracketKeyword_1_9();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Conditional_IfFalseExpressionAssignment_1_8(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}



/************ end Rule Conditional ****************/


/************ begin Rule OrExpression ****************
 *
 * / *
 * 
 *  * Binary expressions
 * 
 *  * / OrExpression returns IntegerExpression:
 * 
 * 	AndExpression ({Or.left=current} "|" right=AndExpression)*;
 *
 **/

// AndExpression ({Or.left=current} "|" right=AndExpression)*
protected class OrExpression_Group extends GroupToken {
	
	public OrExpression_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getOrExpressionAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new OrExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new OrExpression_AndExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// AndExpression
protected class OrExpression_AndExpressionParserRuleCall_0 extends RuleCallToken {
	
	public OrExpression_AndExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AndExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(AndExpression_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({Or.left=current} "|" right=AndExpression)*
protected class OrExpression_Group_1 extends GroupToken {
	
	public OrExpression_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getOrExpressionAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new OrExpression_RightAssignment_1_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Or.left=current}
protected class OrExpression_OrLeftAction_1_0 extends ActionToken  {

	public OrExpression_OrLeftAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new OrExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new OrExpression_AndExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "|"
protected class OrExpression_VerticalLineKeyword_1_1 extends KeywordToken  {
	
	public OrExpression_VerticalLineKeyword_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getOrExpressionAccess().getVerticalLineKeyword_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new OrExpression_OrLeftAction_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// right=AndExpression
protected class OrExpression_RightAssignment_1_2 extends AssignmentToken  {
	
	public OrExpression_RightAssignment_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getOrExpressionAccess().getRightAssignment_1_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AndExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("right",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAndExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new OrExpression_VerticalLineKeyword_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule OrExpression ****************/


/************ begin Rule AndExpression ****************
 *
 * AndExpression returns IntegerExpression:
 * 
 * 	EqualExpression ({And.left=current} "&" right=EqualExpression)*;
 *
 **/

// EqualExpression ({And.left=current} "&" right=EqualExpression)*
protected class AndExpression_Group extends GroupToken {
	
	public AndExpression_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAndExpressionAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AndExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AndExpression_EqualExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// EqualExpression
protected class AndExpression_EqualExpressionParserRuleCall_0 extends RuleCallToken {
	
	public AndExpression_EqualExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAndExpressionAccess().getEqualExpressionParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EqualExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(EqualExpression_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({And.left=current} "&" right=EqualExpression)*
protected class AndExpression_Group_1 extends GroupToken {
	
	public AndExpression_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAndExpressionAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AndExpression_RightAssignment_1_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {And.left=current}
protected class AndExpression_AndLeftAction_1_0 extends ActionToken  {

	public AndExpression_AndLeftAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AndExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AndExpression_EqualExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "&"
protected class AndExpression_AmpersandKeyword_1_1 extends KeywordToken  {
	
	public AndExpression_AmpersandKeyword_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getAndExpressionAccess().getAmpersandKeyword_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AndExpression_AndLeftAction_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// right=EqualExpression
protected class AndExpression_RightAssignment_1_2 extends AssignmentToken  {
	
	public AndExpression_RightAssignment_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAndExpressionAccess().getRightAssignment_1_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EqualExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("right",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getEqualExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getAndExpressionAccess().getRightEqualExpressionParserRuleCall_1_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new AndExpression_AmpersandKeyword_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule AndExpression ****************/


/************ begin Rule EqualExpression ****************
 *
 * EqualExpression returns IntegerExpression:
 * 
 * 	ComparisonExpression ({Equal.left=current} "==" right=ComparisonExpression)*;
 *
 **/

// ComparisonExpression ({Equal.left=current} "==" right=ComparisonExpression)*
protected class EqualExpression_Group extends GroupToken {
	
	public EqualExpression_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEqualExpressionAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EqualExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new EqualExpression_ComparisonExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// ComparisonExpression
protected class EqualExpression_ComparisonExpressionParserRuleCall_0 extends RuleCallToken {
	
	public EqualExpression_ComparisonExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getEqualExpressionAccess().getComparisonExpressionParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(ComparisonExpression_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// ({Equal.left=current} "==" right=ComparisonExpression)*
protected class EqualExpression_Group_1 extends GroupToken {
	
	public EqualExpression_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEqualExpressionAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EqualExpression_RightAssignment_1_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Equal.left=current}
protected class EqualExpression_EqualLeftAction_1_0 extends ActionToken  {

	public EqualExpression_EqualLeftAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EqualExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new EqualExpression_ComparisonExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "=="
protected class EqualExpression_EqualsSignEqualsSignKeyword_1_1 extends KeywordToken  {
	
	public EqualExpression_EqualsSignEqualsSignKeyword_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getEqualExpressionAccess().getEqualsSignEqualsSignKeyword_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EqualExpression_EqualLeftAction_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// right=ComparisonExpression
protected class EqualExpression_RightAssignment_1_2 extends AssignmentToken  {
	
	public EqualExpression_RightAssignment_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEqualExpressionAccess().getRightAssignment_1_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("right",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getComparisonExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEqualExpressionAccess().getRightComparisonExpressionParserRuleCall_1_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new EqualExpression_EqualsSignEqualsSignKeyword_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule EqualExpression ****************/


/************ begin Rule ComparisonExpression ****************
 *
 * ComparisonExpression returns IntegerExpression:
 * 
 * 	AddExpression (({Greater.left=current} ">" | {Lower.left=current} "<") right=AddExpression)*;
 *
 **/

// AddExpression (({Greater.left=current} ">" | {Lower.left=current} "<") right=AddExpression)*
protected class ComparisonExpression_Group extends GroupToken {
	
	public ComparisonExpression_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ComparisonExpression_AddExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// AddExpression
protected class ComparisonExpression_AddExpressionParserRuleCall_0 extends RuleCallToken {
	
	public ComparisonExpression_AddExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getAddExpressionParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(AddExpression_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// (({Greater.left=current} ">" | {Lower.left=current} "<") right=AddExpression)*
protected class ComparisonExpression_Group_1 extends GroupToken {
	
	public ComparisonExpression_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Greater.left=current} ">" | {Lower.left=current} "<"
protected class ComparisonExpression_Alternatives_1_0 extends AlternativesToken {

	public ComparisonExpression_Alternatives_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getAlternatives_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ComparisonExpression_Group_1_0_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// {Greater.left=current} ">"
protected class ComparisonExpression_Group_1_0_0 extends GroupToken {
	
	public ComparisonExpression_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getGroup_1_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_GreaterThanSignKeyword_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Greater.left=current}
protected class ComparisonExpression_GreaterLeftAction_1_0_0_0 extends ActionToken  {

	public ComparisonExpression_GreaterLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ComparisonExpression_AddExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// ">"
protected class ComparisonExpression_GreaterThanSignKeyword_1_0_0_1 extends KeywordToken  {
	
	public ComparisonExpression_GreaterThanSignKeyword_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getGreaterThanSignKeyword_1_0_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_GreaterLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


// {Lower.left=current} "<"
protected class ComparisonExpression_Group_1_0_1 extends GroupToken {
	
	public ComparisonExpression_Group_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getGroup_1_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_LessThanSignKeyword_1_0_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Lower.left=current}
protected class ComparisonExpression_LowerLeftAction_1_0_1_0 extends ActionToken  {

	public ComparisonExpression_LowerLeftAction_1_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new ComparisonExpression_AddExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "<"
protected class ComparisonExpression_LessThanSignKeyword_1_0_1_1 extends KeywordToken  {
	
	public ComparisonExpression_LessThanSignKeyword_1_0_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getLessThanSignKeyword_1_0_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new ComparisonExpression_LowerLeftAction_1_0_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}



// right=AddExpression
protected class ComparisonExpression_RightAssignment_1_1 extends AssignmentToken  {
	
	public ComparisonExpression_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("right",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAddExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getComparisonExpressionAccess().getRightAddExpressionParserRuleCall_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new ComparisonExpression_Alternatives_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule ComparisonExpression ****************/


/************ begin Rule AddExpression ****************
 *
 * AddExpression returns IntegerExpression:
 * 
 * 	MultExpression (({Add.left=current} "+" | {Minus.left=current} "-") right=MultExpression)*;
 *
 **/

// MultExpression (({Add.left=current} "+" | {Minus.left=current} "-") right=MultExpression)*
protected class AddExpression_Group extends GroupToken {
	
	public AddExpression_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AddExpression_MultExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// MultExpression
protected class AddExpression_MultExpressionParserRuleCall_0 extends RuleCallToken {
	
	public AddExpression_MultExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getMultExpressionParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(MultExpression_Group.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// (({Add.left=current} "+" | {Minus.left=current} "-") right=MultExpression)*
protected class AddExpression_Group_1 extends GroupToken {
	
	public AddExpression_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Add.left=current} "+" | {Minus.left=current} "-"
protected class AddExpression_Alternatives_1_0 extends AlternativesToken {

	public AddExpression_Alternatives_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getAlternatives_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AddExpression_Group_1_0_1(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

}

// {Add.left=current} "+"
protected class AddExpression_Group_1_0_0 extends GroupToken {
	
	public AddExpression_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getGroup_1_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_PlusSignKeyword_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Add.left=current}
protected class AddExpression_AddLeftAction_1_0_0_0 extends ActionToken  {

	public AddExpression_AddLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AddExpression_MultExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "+"
protected class AddExpression_PlusSignKeyword_1_0_0_1 extends KeywordToken  {
	
	public AddExpression_PlusSignKeyword_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getPlusSignKeyword_1_0_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_AddLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


// {Minus.left=current} "-"
protected class AddExpression_Group_1_0_1 extends GroupToken {
	
	public AddExpression_Group_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getGroup_1_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_HyphenMinusKeyword_1_0_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Minus.left=current}
protected class AddExpression_MinusLeftAction_1_0_1_0 extends ActionToken  {

	public AddExpression_MinusLeftAction_1_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new AddExpression_MultExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "-"
protected class AddExpression_HyphenMinusKeyword_1_0_1_1 extends KeywordToken  {
	
	public AddExpression_HyphenMinusKeyword_1_0_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getHyphenMinusKeyword_1_0_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new AddExpression_MinusLeftAction_1_0_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}



// right=MultExpression
protected class AddExpression_RightAssignment_1_1 extends AssignmentToken  {
	
	public AddExpression_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAddExpressionAccess().getRightAssignment_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_Group(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("right",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getMultExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getAddExpressionAccess().getRightMultExpressionParserRuleCall_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new AddExpression_Alternatives_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule AddExpression ****************/


/************ begin Rule MultExpression ****************
 *
 * MultExpression returns IntegerExpression:
 * 
 * 	UnaryExpression (({Mult.left=current} "*" | {Div.left=current} "/" | {Mod.left=current} "%") right=UnaryExpression)*;
 *
 **/

// UnaryExpression (({Mult.left=current} "*" | {Div.left=current} "/" | {Mod.left=current} "%") right=UnaryExpression)*
protected class MultExpression_Group extends GroupToken {
	
	public MultExpression_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new MultExpression_UnaryExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// UnaryExpression
protected class MultExpression_UnaryExpressionParserRuleCall_0 extends RuleCallToken {
	
	public MultExpression_UnaryExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getUnaryExpressionParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnaryExpression_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(UnaryExpression_Alternatives.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// (({Mult.left=current} "*" | {Div.left=current} "/" | {Mod.left=current} "%") right=UnaryExpression)*
protected class MultExpression_Group_1 extends GroupToken {
	
	public MultExpression_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_RightAssignment_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Mult.left=current} "*" | {Div.left=current} "/" | {Mod.left=current} "%"
protected class MultExpression_Alternatives_1_0 extends AlternativesToken {

	public MultExpression_Alternatives_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getAlternatives_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_Group_1_0_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new MultExpression_Group_1_0_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new MultExpression_Group_1_0_2(lastRuleCallOrigin, this, 2, inst);
			default: return null;
		}	
	}

}

// {Mult.left=current} "*"
protected class MultExpression_Group_1_0_0 extends GroupToken {
	
	public MultExpression_Group_1_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getGroup_1_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_AsteriskKeyword_1_0_0_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Mult.left=current}
protected class MultExpression_MultLeftAction_1_0_0_0 extends ActionToken  {

	public MultExpression_MultLeftAction_1_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new MultExpression_UnaryExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "*"
protected class MultExpression_AsteriskKeyword_1_0_0_1 extends KeywordToken  {
	
	public MultExpression_AsteriskKeyword_1_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getAsteriskKeyword_1_0_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_MultLeftAction_1_0_0_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


// {Div.left=current} "/"
protected class MultExpression_Group_1_0_1 extends GroupToken {
	
	public MultExpression_Group_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getGroup_1_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_SolidusKeyword_1_0_1_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Div.left=current}
protected class MultExpression_DivLeftAction_1_0_1_0 extends ActionToken  {

	public MultExpression_DivLeftAction_1_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new MultExpression_UnaryExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "/"
protected class MultExpression_SolidusKeyword_1_0_1_1 extends KeywordToken  {
	
	public MultExpression_SolidusKeyword_1_0_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getSolidusKeyword_1_0_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_DivLeftAction_1_0_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}


// {Mod.left=current} "%"
protected class MultExpression_Group_1_0_2 extends GroupToken {
	
	public MultExpression_Group_1_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getGroup_1_0_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_PercentSignKeyword_1_0_2_1(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Mod.left=current}
protected class MultExpression_ModLeftAction_1_0_2_0 extends ActionToken  {

	public MultExpression_ModLeftAction_1_0_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new MultExpression_UnaryExpressionParserRuleCall_0(lastRuleCallOrigin, this, 1, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		Object val = eObjectConsumer.getConsumable("left", false);
		if(val == null) return null;
		if(!eObjectConsumer.isConsumedWithLastConsumtion("left")) return null;
		return createEObjectConsumer((EObject) val);
	}
}

// "%"
protected class MultExpression_PercentSignKeyword_1_0_2_1 extends KeywordToken  {
	
	public MultExpression_PercentSignKeyword_1_0_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getPercentSignKeyword_1_0_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new MultExpression_ModLeftAction_1_0_2_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}



// right=UnaryExpression
protected class MultExpression_RightAssignment_1_1 extends AssignmentToken  {
	
	public MultExpression_RightAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getMultExpressionAccess().getRightAssignment_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnaryExpression_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("right",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("right");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getUnaryExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getMultExpressionAccess().getRightUnaryExpressionParserRuleCall_1_1_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new MultExpression_Alternatives_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule MultExpression ****************/


/************ begin Rule UnaryExpression ****************
 *
 * / *
 * 
 *  * Unary expressions
 * 
 *  * / UnaryExpression returns IntegerExpression:
 * 
 * 	LiteralsExpression | {Not} "!" target=LiteralsExpression | {UMinus} "-" target=LiteralsExpression;
 *
 **/

// LiteralsExpression | {Not} "!" target=LiteralsExpression | {UMinus} "-" target=LiteralsExpression
protected class UnaryExpression_Alternatives extends AlternativesToken {

	public UnaryExpression_Alternatives(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getAlternatives();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnaryExpression_LiteralsExpressionParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new UnaryExpression_Group_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new UnaryExpression_Group_2(lastRuleCallOrigin, this, 2, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAddExpressionAccess().getAddLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAndExpressionAccess().getAndLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getConditionalAccess().getConditionalAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getDivLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEqualExpressionAccess().getEqualLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getGreaterLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getComparisonExpressionAccess().getLowerLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getAddExpressionAccess().getMinusLeftAction_1_0_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getModLeftAction_1_0_2_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getMultExpressionAccess().getMultLeftAction_1_0_0_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getOrExpressionAccess().getOrLeftAction_1_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getPositionLiteralAccess().getPositionLiteralAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// LiteralsExpression
protected class UnaryExpression_LiteralsExpressionParserRuleCall_0 extends RuleCallToken {
	
	public UnaryExpression_LiteralsExpressionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getLiteralsExpressionParserRuleCall_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new LiteralsExpression_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(checkForRecursion(LiteralsExpression_Alternatives.class, eObjectConsumer)) return null;
		return eObjectConsumer;
	}
	
    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, inst);
		}	
	}	
}

// {Not} "!" target=LiteralsExpression
protected class UnaryExpression_Group_1 extends GroupToken {
	
	public UnaryExpression_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getGroup_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnaryExpression_TargetAssignment_1_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getNotAction_1_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {Not}
protected class UnaryExpression_NotAction_1_0 extends ActionToken  {

	public UnaryExpression_NotAction_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getNotAction_1_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// "!"
protected class UnaryExpression_ExclamationMarkKeyword_1_1 extends KeywordToken  {
	
	public UnaryExpression_ExclamationMarkKeyword_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getExclamationMarkKeyword_1_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnaryExpression_NotAction_1_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// target=LiteralsExpression
protected class UnaryExpression_TargetAssignment_1_2 extends AssignmentToken  {
	
	public UnaryExpression_TargetAssignment_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getTargetAssignment_1_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new LiteralsExpression_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("target",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("target");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getLiteralsExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getUnaryExpressionAccess().getTargetLiteralsExpressionParserRuleCall_1_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new UnaryExpression_ExclamationMarkKeyword_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// {UMinus} "-" target=LiteralsExpression
protected class UnaryExpression_Group_2 extends GroupToken {
	
	public UnaryExpression_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getGroup_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnaryExpression_TargetAssignment_2_2(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// {UMinus}
protected class UnaryExpression_UMinusAction_2_0 extends ActionToken  {

	public UnaryExpression_UMinusAction_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getUMinusAction_2_0();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(!eObjectConsumer.isConsumed()) return null;
		return eObjectConsumer;
	}
}

// "-"
protected class UnaryExpression_HyphenMinusKeyword_2_1 extends KeywordToken  {
	
	public UnaryExpression_HyphenMinusKeyword_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getHyphenMinusKeyword_2_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new UnaryExpression_UMinusAction_2_0(lastRuleCallOrigin, this, 0, inst);
			default: return null;
		}	
	}

}

// target=LiteralsExpression
protected class UnaryExpression_TargetAssignment_2_2 extends AssignmentToken  {
	
	public UnaryExpression_TargetAssignment_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getUnaryExpressionAccess().getTargetAssignment_2_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new LiteralsExpression_Alternatives(this, this, 0, inst);
			default: return null;
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("target",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("target");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getLiteralsExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getUnaryExpressionAccess().getTargetLiteralsExpressionParserRuleCall_2_2_0(); 
				consumed = obj;
				return param;
			}
		}
		return null;
	}

    @Override
	public AbstractToken createFollowerAfterReturn(AbstractToken next,	int actIndex, int index, IEObjectConsumer inst) {
		if(value == inst.getEObject() && !inst.isConsumed()) return null;
		switch(index) {
			case 0: return new UnaryExpression_HyphenMinusKeyword_2_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



/************ end Rule UnaryExpression ****************/


/************ begin Rule IntegerLiteral ****************
 *
 * IntegerLiteral:
 * 
 * 	val=EInt;
 *
 **/

// val=EInt
protected class IntegerLiteral_ValAssignment extends AssignmentToken  {
	
	public IntegerLiteral_ValAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getIntegerLiteralAccess().getValAssignment();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getIntegerLiteralRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("val",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("val");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIntegerLiteralAccess().getValEIntParserRuleCall_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getIntegerLiteralAccess().getValEIntParserRuleCall_0();
			return obj;
		}
		return null;
	}

}

/************ end Rule IntegerLiteral ****************/


}