ScxmlxtParsetreeConstructor.java

/*
* generated by Xtext
*/
package no.hal.scxml.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 no.hal.scxml.services.ScxmlxtGrammarAccess;

import com.google.inject.Inject;

@SuppressWarnings("all")
public class ScxmlxtParsetreeConstructor extends AbstractParseTreeConstructor {
		
	@Inject
	private ScxmlxtGrammarAccess 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 StateMachine_Group(this, this, 0, inst);
			case 1: return new ResourceImport_Alternatives(this, this, 1, inst);
			case 2: return new DomainModelImport_Group(this, this, 2, inst);
			case 3: return new DomainDataImport_Group(this, this, 3, inst);
			case 4: return new State_Group(this, this, 4, inst);
			case 5: return new InitialTransition_Group(this, this, 5, inst);
			case 6: return new AbstractState_Alternatives(this, this, 6, inst);
			case 7: return new AbstractTransition_Alternatives(this, this, 7, inst);
			case 8: return new Transition_Group(this, this, 8, inst);
			case 9: return new InternalTransition_Group(this, this, 9, inst);
			case 10: return new Event_Alternatives(this, this, 10, inst);
			case 11: return new SymbolicEvent_Group(this, this, 11, inst);
			case 12: return new TransitionEvent_Alternatives(this, this, 12, inst);
			case 13: return new EnterEvent_Group(this, this, 13, inst);
			case 14: return new ExitEvent_Group(this, this, 14, inst);
			case 15: return new ScriptEvent_ScriptAssignment(this, this, 15, inst);
			case 16: return new TimerEvent_Group(this, this, 16, inst);
			case 17: return new Condition_ScriptAssignment(this, this, 17, inst);
			case 18: return new Action_Alternatives(this, this, 18, inst);
			case 19: return new SymbolicAction_Group(this, this, 19, inst);
			case 20: return new ScriptAction_ScriptAssignment(this, this, 20, inst);
			case 21: return new VarDef_Group(this, this, 21, inst);
			case 22: return new AssignmentAction_Group(this, this, 22, inst);
			case 23: return new Expression_Alternatives(this, this, 23, inst);
			case 24: return new Literal_Alternatives(this, this, 24, inst);
			case 25: return new BooleanLiteral_BooleanValueAssignment(this, this, 25, inst);
			case 26: return new IntLiteral_IntValueAssignment(this, this, 26, inst);
			case 27: return new FloatLiteral_FloatValueAssignment(this, this, 27, inst);
			case 28: return new StringLiteral_StringValueAssignment(this, this, 28, inst);
			case 29: return new UriLiteral_UriAssignment(this, this, 29, inst);
			case 30: return new EObjectUriLiteral_UriAssignment(this, this, 30, inst);
			case 31: return new DelayLiteral_Group(this, this, 31, inst);
			case 32: return new VarRef_VarAssignment(this, this, 32, inst);
			case 33: return new EPath_Group(this, this, 33, inst);
			case 34: return new EStep_Group(this, this, 34, inst);
			case 35: return new EStepFilter_ScriptAssignment(this, this, 35, inst);
			case 36: return new ScriptExpression_ScriptAssignment(this, this, 36, inst);
			default: return null;
		}	
	}	
}
	

/************ begin Rule StateMachine ****************
 *
 * StateMachine:
 * 	imports+=ResourceImport* (states+=State | transitions+=AbstractTransition | variables+=VarDef)*;
 *
 **/

// imports+=ResourceImport* (states+=State | transitions+=AbstractTransition | variables+=VarDef)*
protected class StateMachine_Group extends GroupToken {
	
	public StateMachine_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getStateMachineAccess().getGroup();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new StateMachine_Alternatives_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new StateMachine_ImportsAssignment_0(lastRuleCallOrigin, this, 1, inst);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index - 2, inst);
		}	
	}

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

}

// imports+=ResourceImport*
protected class StateMachine_ImportsAssignment_0 extends AssignmentToken  {
	
	public StateMachine_ImportsAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateMachineAccess().getImportsAssignment_0();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("imports",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("imports");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getResourceImportRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getStateMachineAccess().getImportsResourceImportParserRuleCall_0_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 StateMachine_ImportsAssignment_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index - 1, consumed);
		}	
	}	
}

// (states+=State | transitions+=AbstractTransition | variables+=VarDef)*
protected class StateMachine_Alternatives_1 extends AlternativesToken {

	public StateMachine_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getStateMachineAccess().getAlternatives_1();
	}

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

}

// states+=State
protected class StateMachine_StatesAssignment_1_0 extends AssignmentToken  {
	
	public StateMachine_StatesAssignment_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateMachineAccess().getStatesAssignment_1_0();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("states",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("states");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getStateRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_1_0_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 StateMachine_Alternatives_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new StateMachine_ImportsAssignment_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index - 2, consumed);
		}	
	}	
}

// transitions+=AbstractTransition
protected class StateMachine_TransitionsAssignment_1_1 extends AssignmentToken  {
	
	public StateMachine_TransitionsAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateMachineAccess().getTransitionsAssignment_1_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("transitions",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("transitions");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAbstractTransitionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getStateMachineAccess().getTransitionsAbstractTransitionParserRuleCall_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 StateMachine_Alternatives_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new StateMachine_ImportsAssignment_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index - 2, consumed);
		}	
	}	
}

// variables+=VarDef
protected class StateMachine_VariablesAssignment_1_2 extends AssignmentToken  {
	
	public StateMachine_VariablesAssignment_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateMachineAccess().getVariablesAssignment_1_2();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("variables",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("variables");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getVarDefRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getStateMachineAccess().getVariablesVarDefParserRuleCall_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 StateMachine_Alternatives_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new StateMachine_ImportsAssignment_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index - 2, consumed);
		}	
	}	
}



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


/************ begin Rule ResourceImport ****************
 *
 * ResourceImport:
 * 	DomainModelImport | DomainDataImport;
 *
 **/

// DomainModelImport | DomainDataImport
protected class ResourceImport_Alternatives extends AlternativesToken {

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

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

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

}

// DomainModelImport
protected class ResourceImport_DomainModelImportParserRuleCall_0 extends RuleCallToken {
	
	public ResourceImport_DomainModelImportParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getResourceImportAccess().getDomainModelImportParserRuleCall_0();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getDomainModelImportRule().getType().getClassifier())
			return null;
		if(checkForRecursion(DomainModelImport_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);
		}	
	}	
}

// DomainDataImport
protected class ResourceImport_DomainDataImportParserRuleCall_1 extends RuleCallToken {
	
	public ResourceImport_DomainDataImportParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getResourceImportAccess().getDomainDataImportParserRuleCall_1();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getDomainDataImportRule().getType().getClassifier())
			return null;
		if(checkForRecursion(DomainDataImport_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);
		}	
	}	
}


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


/************ begin Rule DomainModelImport ****************
 *
 * DomainModelImport:
 * 	"domain"? "model" importURI=STRING ";";
 *
 **/

// "domain"? "model" importURI=STRING ";"
protected class DomainModelImport_Group extends GroupToken {
	
	public DomainModelImport_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getDomainModelImportAccess().getGroup();
	}

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

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

}

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

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

}

// importURI=STRING
protected class DomainModelImport_ImportURIAssignment_2 extends AssignmentToken  {
	
	public DomainModelImport_ImportURIAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getDomainModelImportAccess().getImportURIAssignment_2();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("importURI",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("importURI");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getDomainModelImportAccess().getImportURISTRINGTerminalRuleCall_2_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getDomainModelImportAccess().getImportURISTRINGTerminalRuleCall_2_0();
			return obj;
		}
		return null;
	}

}

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

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

}


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


/************ begin Rule DomainDataImport ****************
 *
 * DomainDataImport:
 * 	"domain"? "data" importURI=STRING ";";
 *
 **/

// "domain"? "data" importURI=STRING ";"
protected class DomainDataImport_Group extends GroupToken {
	
	public DomainDataImport_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getDomainDataImportAccess().getGroup();
	}

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

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

}

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

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

}

// importURI=STRING
protected class DomainDataImport_ImportURIAssignment_2 extends AssignmentToken  {
	
	public DomainDataImport_ImportURIAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getDomainDataImportAccess().getImportURIAssignment_2();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("importURI",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("importURI");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getDomainDataImportAccess().getImportURISTRINGTerminalRuleCall_2_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getDomainDataImportAccess().getImportURISTRINGTerminalRuleCall_2_0();
			return obj;
		}
		return null;
	}

}

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

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

}


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


/************ begin Rule State ****************
 *
 * State:
 * 	initialTransition=InitialTransition? name=ID (";" | "{" (states+=State | transitions+=AbstractTransition |
 * 	variables+=VarDef)* "}");
 *
 **/

// initialTransition=InitialTransition? name=ID (";" | "{" (states+=State | transitions+=AbstractTransition |
// variables+=VarDef)* "}")
protected class State_Group extends GroupToken {
	
	public State_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getStateAccess().getGroup();
	}

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

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

}

// initialTransition=InitialTransition?
protected class State_InitialTransitionAssignment_0 extends AssignmentToken  {
	
	public State_InitialTransitionAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateAccess().getInitialTransitionAssignment_0();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("initialTransition",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("initialTransition");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getInitialTransitionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getStateAccess().getInitialTransitionInitialTransitionParserRuleCall_0_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) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
		}	
	}	
}

// name=ID
protected class State_NameAssignment_1 extends AssignmentToken  {
	
	public State_NameAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateAccess().getNameAssignment_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new State_InitialTransitionAssignment_0(lastRuleCallOrigin, this, 0, inst);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index - 1, inst);
		}	
	}

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getStateAccess().getNameIDTerminalRuleCall_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getStateAccess().getNameIDTerminalRuleCall_1_0();
			return obj;
		}
		return null;
	}

}

// ";" | "{" (states+=State | transitions+=AbstractTransition | variables+=VarDef)* "}"
protected class State_Alternatives_2 extends AlternativesToken {

	public State_Alternatives_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getStateAccess().getAlternatives_2();
	}

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

}

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

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

}

// "{" (states+=State | transitions+=AbstractTransition | variables+=VarDef)* "}"
protected class State_Group_2_1 extends GroupToken {
	
	public State_Group_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getStateAccess().getGroup_2_1();
	}

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

}

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

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

}

// (states+=State | transitions+=AbstractTransition | variables+=VarDef)*
protected class State_Alternatives_2_1_1 extends AlternativesToken {

	public State_Alternatives_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getStateAccess().getAlternatives_2_1_1();
	}

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

}

// states+=State
protected class State_StatesAssignment_2_1_1_0 extends AssignmentToken  {
	
	public State_StatesAssignment_2_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateAccess().getStatesAssignment_2_1_1_0();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("states",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("states");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getStateRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getStateAccess().getStatesStateParserRuleCall_2_1_1_0_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 State_Alternatives_2_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new State_LeftCurlyBracketKeyword_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// transitions+=AbstractTransition
protected class State_TransitionsAssignment_2_1_1_1 extends AssignmentToken  {
	
	public State_TransitionsAssignment_2_1_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateAccess().getTransitionsAssignment_2_1_1_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("transitions",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("transitions");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAbstractTransitionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getStateAccess().getTransitionsAbstractTransitionParserRuleCall_2_1_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 State_Alternatives_2_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new State_LeftCurlyBracketKeyword_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

// variables+=VarDef
protected class State_VariablesAssignment_2_1_1_2 extends AssignmentToken  {
	
	public State_VariablesAssignment_2_1_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStateAccess().getVariablesAssignment_2_1_1_2();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("variables",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("variables");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getVarDefRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getStateAccess().getVariablesVarDefParserRuleCall_2_1_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 State_Alternatives_2_1_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new State_LeftCurlyBracketKeyword_2_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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

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

}




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


/************ begin Rule InitialTransition ****************
 *
 * InitialTransition: //	('->' target=[State] |	target=[State] '<-')
 * 	{InitialTransition} "->" ("do" action=Action)?;
 *
 **/

// //	('->' target=[State] |	target=[State] '<-')
// {InitialTransition} "->" ("do" action=Action)?
protected class InitialTransition_Group extends GroupToken {
	
	public InitialTransition_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getInitialTransitionAccess().getGroup();
	}

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

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

}

// //	('->' target=[State] |	target=[State] '<-')
// {InitialTransition}
protected class InitialTransition_InitialTransitionAction_0 extends ActionToken  {

	public InitialTransition_InitialTransitionAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getInitialTransitionAccess().getInitialTransitionAction_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 InitialTransition_HyphenMinusGreaterThanSignKeyword_1 extends KeywordToken  {
	
	public InitialTransition_HyphenMinusGreaterThanSignKeyword_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Keyword getGrammarElement() {
		return grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_1();
	}

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

}

// ("do" action=Action)?
protected class InitialTransition_Group_2 extends GroupToken {
	
	public InitialTransition_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getInitialTransitionAccess().getGroup_2();
	}

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

}

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

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

}

// action=Action
protected class InitialTransition_ActionAssignment_2_1 extends AssignmentToken  {
	
	public InitialTransition_ActionAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getInitialTransitionAccess().getActionAssignment_2_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("action",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("action");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getActionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getInitialTransitionAccess().getActionActionParserRuleCall_2_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 InitialTransition_DoKeyword_2_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}



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


/************ begin Rule AbstractState ****************
 *
 * AbstractState:
 * 	StateMachine | State;
 *
 **/

// StateMachine | State
protected class AbstractState_Alternatives extends AlternativesToken {

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

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

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

}

// StateMachine
protected class AbstractState_StateMachineParserRuleCall_0 extends RuleCallToken {
	
	public AbstractState_StateMachineParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractStateAccess().getStateMachineParserRuleCall_0();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getStateMachineRule().getType().getClassifier())
			return null;
		if(checkForRecursion(StateMachine_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);
		}	
	}	
}

// State
protected class AbstractState_StateParserRuleCall_1 extends RuleCallToken {
	
	public AbstractState_StateParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractStateAccess().getStateParserRuleCall_1();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getStateRule().getType().getClassifier())
			return null;
		if(checkForRecursion(State_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);
		}	
	}	
}


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


/************ begin Rule AbstractTransition ****************
 *
 * AbstractTransition:
 * 	Transition | InternalTransition;
 *
 **/

// Transition | InternalTransition
protected class AbstractTransition_Alternatives extends AlternativesToken {

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

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

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

}

// Transition
protected class AbstractTransition_TransitionParserRuleCall_0 extends RuleCallToken {
	
	public AbstractTransition_TransitionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTransitionAccess().getTransitionParserRuleCall_0();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTransitionRule().getType().getClassifier())
			return null;
		if(checkForRecursion(Transition_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);
		}	
	}	
}

// InternalTransition
protected class AbstractTransition_InternalTransitionParserRuleCall_1 extends RuleCallToken {
	
	public AbstractTransition_InternalTransitionParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getAbstractTransitionAccess().getInternalTransitionParserRuleCall_1();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getInternalTransitionRule().getType().getClassifier())
			return null;
		if(checkForRecursion(InternalTransition_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);
		}	
	}	
}


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


/************ begin Rule Transition ****************
 *
 * Transition:
 * 	("->" target=[State|QNAME] // (source=[State|QNAME] '->' target=[State|QNAME] | target=[State|QNAME] '<-' source=[State|QNAME])
 * 	| target=[State|QNAME] "<-") ("on" event=Event)? ("if" condition=Condition)? ("do" action=Action)? ";";
 *
 **/

// ("->" target=[State|QNAME] // (source=[State|QNAME] '->' target=[State|QNAME] | target=[State|QNAME] '<-' source=[State|QNAME])
// | target=[State|QNAME] "<-") ("on" event=Event)? ("if" condition=Condition)? ("do" action=Action)? ";"
protected class Transition_Group extends GroupToken {
	
	public Transition_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionAccess().getGroup();
	}

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

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

}

// "->" target=[State|QNAME] // (source=[State|QNAME] '->' target=[State|QNAME] | target=[State|QNAME] '<-' source=[State|QNAME])
// | target=[State|QNAME] "<-"
protected class Transition_Alternatives_0 extends AlternativesToken {

	public Transition_Alternatives_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getTransitionAccess().getAlternatives_0();
	}

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

}

// "->" target=[State|QNAME]
protected class Transition_Group_0_0 extends GroupToken {
	
	public Transition_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionAccess().getGroup_0_0();
	}

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

}

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

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

}

// target=[State|QNAME]
protected class Transition_TargetAssignment_0_0_1 extends AssignmentToken  {
	
	public Transition_TargetAssignment_0_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionAccess().getTargetAssignment_0_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Transition_HyphenMinusGreaterThanSignKeyword_0_0_0(lastRuleCallOrigin, 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::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionAccess().getTargetStateCrossReference_0_0_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionAccess().getTargetStateCrossReference_0_0_1_0(); 
				return obj;
			}
		}
		return null;
	}

}


// target=[State|QNAME] "<-"
protected class Transition_Group_0_1 extends GroupToken {
	
	public Transition_Group_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionAccess().getGroup_0_1();
	}

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

}

// target=[State|QNAME]
protected class Transition_TargetAssignment_0_1_0 extends AssignmentToken  {
	
	public Transition_TargetAssignment_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionAccess().getTargetAssignment_0_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("target",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("target");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionAccess().getTargetStateCrossReference_0_1_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionAccess().getTargetStateCrossReference_0_1_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

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

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

}



// ("on" event=Event)?
protected class Transition_Group_1 extends GroupToken {
	
	public Transition_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionAccess().getGroup_1();
	}

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

}

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

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

}

// event=Event
protected class Transition_EventAssignment_1_1 extends AssignmentToken  {
	
	public Transition_EventAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionAccess().getEventAssignment_1_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("event",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("event");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getEventRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTransitionAccess().getEventEventParserRuleCall_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 Transition_OnKeyword_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// ("if" condition=Condition)?
protected class Transition_Group_2 extends GroupToken {
	
	public Transition_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionAccess().getGroup_2();
	}

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

}

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

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

}

// condition=Condition
protected class Transition_ConditionAssignment_2_1 extends AssignmentToken  {
	
	public Transition_ConditionAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionAccess().getConditionAssignment_2_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("condition",false)) == 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.getConditionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTransitionAccess().getConditionConditionParserRuleCall_2_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 Transition_IfKeyword_2_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// ("do" action=Action)?
protected class Transition_Group_3 extends GroupToken {
	
	public Transition_Group_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionAccess().getGroup_3();
	}

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

}

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

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

}

// action=Action
protected class Transition_ActionAssignment_3_1 extends AssignmentToken  {
	
	public Transition_ActionAssignment_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionAccess().getActionAssignment_3_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("action",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("action");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getActionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTransitionAccess().getActionActionParserRuleCall_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 Transition_DoKeyword_3_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Transition_Group_3(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Transition_Group_2(lastRuleCallOrigin, this, 1, inst);
			case 2: return new Transition_Group_1(lastRuleCallOrigin, this, 2, inst);
			case 3: return new Transition_Alternatives_0(lastRuleCallOrigin, this, 3, inst);
			default: return null;
		}	
	}

}


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


/************ begin Rule InternalTransition ****************
 *
 * InternalTransition:
 * 	("on" event=Event)? ("if" condition=Condition)? "do" action=Action ";";
 *
 **/

// ("on" event=Event)? ("if" condition=Condition)? "do" action=Action ";"
protected class InternalTransition_Group extends GroupToken {
	
	public InternalTransition_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getInternalTransitionAccess().getGroup();
	}

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

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

}

// ("on" event=Event)?
protected class InternalTransition_Group_0 extends GroupToken {
	
	public InternalTransition_Group_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getInternalTransitionAccess().getGroup_0();
	}

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

}

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

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

}

// event=Event
protected class InternalTransition_EventAssignment_0_1 extends AssignmentToken  {
	
	public InternalTransition_EventAssignment_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getInternalTransitionAccess().getEventAssignment_0_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("event",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("event");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getEventRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getInternalTransitionAccess().getEventEventParserRuleCall_0_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 InternalTransition_OnKeyword_0_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


// ("if" condition=Condition)?
protected class InternalTransition_Group_1 extends GroupToken {
	
	public InternalTransition_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getInternalTransitionAccess().getGroup_1();
	}

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

}

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

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new InternalTransition_Group_0(lastRuleCallOrigin, this, 0, inst);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index - 1, inst);
		}	
	}

}

// condition=Condition
protected class InternalTransition_ConditionAssignment_1_1 extends AssignmentToken  {
	
	public InternalTransition_ConditionAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getInternalTransitionAccess().getConditionAssignment_1_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("condition",false)) == 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.getConditionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getInternalTransitionAccess().getConditionConditionParserRuleCall_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 InternalTransition_IfKeyword_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new InternalTransition_Group_1(lastRuleCallOrigin, this, 0, inst);
			case 1: return new InternalTransition_Group_0(lastRuleCallOrigin, this, 1, inst);
			default: return lastRuleCallOrigin.createFollowerAfterReturn(this, index, index - 2, inst);
		}	
	}

}

// action=Action
protected class InternalTransition_ActionAssignment_3 extends AssignmentToken  {
	
	public InternalTransition_ActionAssignment_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getInternalTransitionAccess().getActionAssignment_3();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("action",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("action");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getActionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getInternalTransitionAccess().getActionActionParserRuleCall_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 InternalTransition_DoKeyword_2(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

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

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

}


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


/************ begin Rule Event ****************
 *
 * Event:
 * 	SymbolicEvent | TransitionEvent | EnterEvent | ExitEvent | ScriptEvent | TimerEvent;
 *
 **/

// SymbolicEvent | TransitionEvent | EnterEvent | ExitEvent | ScriptEvent | TimerEvent
protected class Event_Alternatives extends AlternativesToken {

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

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Event_SymbolicEventParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Event_TransitionEventParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new Event_EnterEventParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
			case 3: return new Event_ExitEventParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
			case 4: return new Event_ScriptEventParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
			case 5: return new Event_TimerEventParserRuleCall_5(lastRuleCallOrigin, this, 5, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnterEventAccess().getEnterEventAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getExitEventAccess().getExitEventAction_0().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getScriptEventRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getSymbolicEventRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getTimerEventRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getTransitionEventRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// SymbolicEvent
protected class Event_SymbolicEventParserRuleCall_0 extends RuleCallToken {
	
	public Event_SymbolicEventParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getEventAccess().getSymbolicEventParserRuleCall_0();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getSymbolicEventRule().getType().getClassifier())
			return null;
		if(checkForRecursion(SymbolicEvent_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);
		}	
	}	
}

// TransitionEvent
protected class Event_TransitionEventParserRuleCall_1 extends RuleCallToken {
	
	public Event_TransitionEventParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getEventAccess().getTransitionEventParserRuleCall_1();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTransitionEventRule().getType().getClassifier())
			return null;
		if(checkForRecursion(TransitionEvent_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);
		}	
	}	
}

// EnterEvent
protected class Event_EnterEventParserRuleCall_2 extends RuleCallToken {
	
	public Event_EnterEventParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getEventAccess().getEnterEventParserRuleCall_2();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEnterEventAccess().getEnterEventAction_0().getType().getClassifier())
			return null;
		if(checkForRecursion(EnterEvent_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);
		}	
	}	
}

// ExitEvent
protected class Event_ExitEventParserRuleCall_3 extends RuleCallToken {
	
	public Event_ExitEventParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getEventAccess().getExitEventParserRuleCall_3();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getExitEventAccess().getExitEventAction_0().getType().getClassifier())
			return null;
		if(checkForRecursion(ExitEvent_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);
		}	
	}	
}

// ScriptEvent
protected class Event_ScriptEventParserRuleCall_4 extends RuleCallToken {
	
	public Event_ScriptEventParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getEventAccess().getScriptEventParserRuleCall_4();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getScriptEventRule().getType().getClassifier())
			return null;
		if(checkForRecursion(ScriptEvent_ScriptAssignment.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);
		}	
	}	
}

// TimerEvent
protected class Event_TimerEventParserRuleCall_5 extends RuleCallToken {
	
	public Event_TimerEventParserRuleCall_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getEventAccess().getTimerEventParserRuleCall_5();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getTimerEventRule().getType().getClassifier())
			return null;
		if(checkForRecursion(TimerEvent_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);
		}	
	}	
}


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


/************ begin Rule SymbolicEvent ****************
 *
 * SymbolicEvent:
 * 	name=ID "!";
 *
 **/

// name=ID "!"
protected class SymbolicEvent_Group extends GroupToken {
	
	public SymbolicEvent_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getSymbolicEventAccess().getGroup();
	}

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

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

}

// name=ID
protected class SymbolicEvent_NameAssignment_0 extends AssignmentToken  {
	
	public SymbolicEvent_NameAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getSymbolicEventAccess().getNameAssignment_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("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getSymbolicEventAccess().getNameIDTerminalRuleCall_0_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getSymbolicEventAccess().getNameIDTerminalRuleCall_0_0();
			return obj;
		}
		return null;
	}

}

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

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

}


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


/************ begin Rule TransitionEvent ****************
 *
 * TransitionEvent:
 * 	(source=[State|QNAME] "->" target=[State|QNAME] | target=[State|QNAME] "<-" source=[State|QNAME]) | ("->"
 * 	target=[State|QNAME] // implicit EnterEvent
 * 	| target=[State|QNAME] "<-") | (source=[State|QNAME] "->" // implicit ExitEvent
 * 	| "<-" source=[State|QNAME]);
 *
 **/

// (source=[State|QNAME] "->" target=[State|QNAME] | target=[State|QNAME] "<-" source=[State|QNAME]) | ("->"
// target=[State|QNAME] // implicit EnterEvent
// | target=[State|QNAME] "<-") | (source=[State|QNAME] "->" // implicit ExitEvent
// | "<-" source=[State|QNAME])
protected class TransitionEvent_Alternatives extends AlternativesToken {

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

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

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

}

// source=[State|QNAME] "->" target=[State|QNAME] | target=[State|QNAME] "<-" source=[State|QNAME]
protected class TransitionEvent_Alternatives_0 extends AlternativesToken {

	public TransitionEvent_Alternatives_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getAlternatives_0();
	}

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

}

// source=[State|QNAME] "->" target=[State|QNAME]
protected class TransitionEvent_Group_0_0 extends GroupToken {
	
	public TransitionEvent_Group_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getGroup_0_0();
	}

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

}

// source=[State|QNAME]
protected class TransitionEvent_SourceAssignment_0_0_0 extends AssignmentToken  {
	
	public TransitionEvent_SourceAssignment_0_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getSourceAssignment_0_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((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionEventAccess().getSourceStateCrossReference_0_0_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionEventAccess().getSourceStateCrossReference_0_0_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

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

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

}

// target=[State|QNAME]
protected class TransitionEvent_TargetAssignment_0_0_2 extends AssignmentToken  {
	
	public TransitionEvent_TargetAssignment_0_0_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getTargetAssignment_0_0_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TransitionEvent_HyphenMinusGreaterThanSignKeyword_0_0_1(lastRuleCallOrigin, 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::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionEventAccess().getTargetStateCrossReference_0_0_2_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionEventAccess().getTargetStateCrossReference_0_0_2_0(); 
				return obj;
			}
		}
		return null;
	}

}


// target=[State|QNAME] "<-" source=[State|QNAME]
protected class TransitionEvent_Group_0_1 extends GroupToken {
	
	public TransitionEvent_Group_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getGroup_0_1();
	}

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

}

// target=[State|QNAME]
protected class TransitionEvent_TargetAssignment_0_1_0 extends AssignmentToken  {
	
	public TransitionEvent_TargetAssignment_0_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getTargetAssignment_0_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("target",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("target");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionEventAccess().getTargetStateCrossReference_0_1_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionEventAccess().getTargetStateCrossReference_0_1_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

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

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

}

// source=[State|QNAME]
protected class TransitionEvent_SourceAssignment_0_1_2 extends AssignmentToken  {
	
	public TransitionEvent_SourceAssignment_0_1_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getSourceAssignment_0_1_2();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionEventAccess().getSourceStateCrossReference_0_1_2_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionEventAccess().getSourceStateCrossReference_0_1_2_0(); 
				return obj;
			}
		}
		return null;
	}

}



// "->" target=[State|QNAME] // implicit EnterEvent
// | target=[State|QNAME] "<-"
protected class TransitionEvent_Alternatives_1 extends AlternativesToken {

	public TransitionEvent_Alternatives_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getAlternatives_1();
	}

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

}

// "->" target=[State|QNAME]
protected class TransitionEvent_Group_1_0 extends GroupToken {
	
	public TransitionEvent_Group_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getGroup_1_0();
	}

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

}

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

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

}

// target=[State|QNAME]
protected class TransitionEvent_TargetAssignment_1_0_1 extends AssignmentToken  {
	
	public TransitionEvent_TargetAssignment_1_0_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getTargetAssignment_1_0_1();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new TransitionEvent_HyphenMinusGreaterThanSignKeyword_1_0_0(lastRuleCallOrigin, 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::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionEventAccess().getTargetStateCrossReference_1_0_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionEventAccess().getTargetStateCrossReference_1_0_1_0(); 
				return obj;
			}
		}
		return null;
	}

}


// target=[State|QNAME] "<-"
protected class TransitionEvent_Group_1_1 extends GroupToken {
	
	public TransitionEvent_Group_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getGroup_1_1();
	}

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

}

// target=[State|QNAME]
protected class TransitionEvent_TargetAssignment_1_1_0 extends AssignmentToken  {
	
	public TransitionEvent_TargetAssignment_1_1_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getTargetAssignment_1_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("target",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("target");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionEventAccess().getTargetStateCrossReference_1_1_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionEventAccess().getTargetStateCrossReference_1_1_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

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

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

}



// source=[State|QNAME] "->" // implicit ExitEvent
// | "<-" source=[State|QNAME]
protected class TransitionEvent_Alternatives_2 extends AlternativesToken {

	public TransitionEvent_Alternatives_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Alternatives getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getAlternatives_2();
	}

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

}

// source=[State|QNAME] "->"
protected class TransitionEvent_Group_2_0 extends GroupToken {
	
	public TransitionEvent_Group_2_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getGroup_2_0();
	}

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

}

// source=[State|QNAME]
protected class TransitionEvent_SourceAssignment_2_0_0 extends AssignmentToken  {
	
	public TransitionEvent_SourceAssignment_2_0_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getSourceAssignment_2_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((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionEventAccess().getSourceStateCrossReference_2_0_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionEventAccess().getSourceStateCrossReference_2_0_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

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

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

}


// "<-" source=[State|QNAME]
protected class TransitionEvent_Group_2_1 extends GroupToken {
	
	public TransitionEvent_Group_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getGroup_2_1();
	}

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

}

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

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

}

// source=[State|QNAME]
protected class TransitionEvent_SourceAssignment_2_1_1 extends AssignmentToken  {
	
	public TransitionEvent_SourceAssignment_2_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTransitionEventAccess().getSourceAssignment_2_1_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("source",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("source");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getTransitionEventAccess().getSourceStateCrossReference_2_1_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getTransitionEventAccess().getSourceStateCrossReference_2_1_1_0(); 
				return obj;
			}
		}
		return null;
	}

}




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


/************ begin Rule EnterEvent ****************
 *
 * EnterEvent:
 * 	{EnterEvent} "enter";
 *
 **/

// {EnterEvent} "enter"
protected class EnterEvent_Group extends GroupToken {
	
	public EnterEvent_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEnterEventAccess().getGroup();
	}

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

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

}

// {EnterEvent}
protected class EnterEvent_EnterEventAction_0 extends ActionToken  {

	public EnterEvent_EnterEventAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getEnterEventAccess().getEnterEventAction_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;
	}
}

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

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

}


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


/************ begin Rule ExitEvent ****************
 *
 * ExitEvent:
 * 	{ExitEvent} "exit";
 *
 **/

// {ExitEvent} "exit"
protected class ExitEvent_Group extends GroupToken {
	
	public ExitEvent_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getExitEventAccess().getGroup();
	}

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

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

}

// {ExitEvent}
protected class ExitEvent_ExitEventAction_0 extends ActionToken  {

	public ExitEvent_ExitEventAction_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Action getGrammarElement() {
		return grammarAccess.getExitEventAccess().getExitEventAction_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;
	}
}

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

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

}


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


/************ begin Rule ScriptEvent ****************
 *
 * ScriptEvent:
 * 	script=SCRIPT_EXPRESSION;
 *
 **/

// script=SCRIPT_EXPRESSION
protected class ScriptEvent_ScriptAssignment extends AssignmentToken  {
	
	public ScriptEvent_ScriptAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getScriptEventAccess().getScriptAssignment();
	}

    @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.getScriptEventRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("script",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("script");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getScriptEventAccess().getScriptSCRIPT_EXPRESSIONTerminalRuleCall_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getScriptEventAccess().getScriptSCRIPT_EXPRESSIONTerminalRuleCall_0();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule TimerEvent ****************
 *
 * TimerEvent:
 * 	"t" ">" delay=Expression "after" event=Event;
 *
 **/

// "t" ">" delay=Expression "after" event=Event
protected class TimerEvent_Group extends GroupToken {
	
	public TimerEvent_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getTimerEventAccess().getGroup();
	}

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

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

}

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

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

}

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

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

}

// delay=Expression
protected class TimerEvent_DelayAssignment_2 extends AssignmentToken  {
	
	public TimerEvent_DelayAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTimerEventAccess().getDelayAssignment_2();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("delay",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("delay");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTimerEventAccess().getDelayExpressionParserRuleCall_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 TimerEvent_GreaterThanSignKeyword_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}

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

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

}

// event=Event
protected class TimerEvent_EventAssignment_4 extends AssignmentToken  {
	
	public TimerEvent_EventAssignment_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getTimerEventAccess().getEventAssignment_4();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("event",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("event");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getEventRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getTimerEventAccess().getEventEventParserRuleCall_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 TimerEvent_AfterKeyword_3(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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


/************ begin Rule Condition ****************
 *
 * Condition:
 * 	script=SCRIPT_EXPRESSION;
 *
 **/

// script=SCRIPT_EXPRESSION
protected class Condition_ScriptAssignment extends AssignmentToken  {
	
	public Condition_ScriptAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getConditionAccess().getScriptAssignment();
	}

    @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.getConditionRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("script",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("script");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getConditionAccess().getScriptSCRIPT_EXPRESSIONTerminalRuleCall_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getConditionAccess().getScriptSCRIPT_EXPRESSIONTerminalRuleCall_0();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule Action ****************
 *
 * Action:
 * 	SymbolicAction | ScriptAction | AssignmentAction;
 *
 **/

// SymbolicAction | ScriptAction | AssignmentAction
protected class Action_Alternatives extends AlternativesToken {

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

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

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

}

// SymbolicAction
protected class Action_SymbolicActionParserRuleCall_0 extends RuleCallToken {
	
	public Action_SymbolicActionParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getActionAccess().getSymbolicActionParserRuleCall_0();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getSymbolicActionRule().getType().getClassifier())
			return null;
		if(checkForRecursion(SymbolicAction_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);
		}	
	}	
}

// ScriptAction
protected class Action_ScriptActionParserRuleCall_1 extends RuleCallToken {
	
	public Action_ScriptActionParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getActionAccess().getScriptActionParserRuleCall_1();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getScriptActionRule().getType().getClassifier())
			return null;
		if(checkForRecursion(ScriptAction_ScriptAssignment.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);
		}	
	}	
}

// AssignmentAction
protected class Action_AssignmentActionParserRuleCall_2 extends RuleCallToken {
	
	public Action_AssignmentActionParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getActionAccess().getAssignmentActionParserRuleCall_2();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getAssignmentActionRule().getType().getClassifier())
			return null;
		if(checkForRecursion(AssignmentAction_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);
		}	
	}	
}


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


/************ begin Rule SymbolicAction ****************
 *
 * SymbolicAction:
 * 	name=ID ("after" delay=Expression)? "!";
 *
 **/

// name=ID ("after" delay=Expression)? "!"
protected class SymbolicAction_Group extends GroupToken {
	
	public SymbolicAction_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getSymbolicActionAccess().getGroup();
	}

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

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

}

// name=ID
protected class SymbolicAction_NameAssignment_0 extends AssignmentToken  {
	
	public SymbolicAction_NameAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getSymbolicActionAccess().getNameAssignment_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("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getSymbolicActionAccess().getNameIDTerminalRuleCall_0_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getSymbolicActionAccess().getNameIDTerminalRuleCall_0_0();
			return obj;
		}
		return null;
	}

}

// ("after" delay=Expression)?
protected class SymbolicAction_Group_1 extends GroupToken {
	
	public SymbolicAction_Group_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getSymbolicActionAccess().getGroup_1();
	}

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

}

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

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

}

// delay=Expression
protected class SymbolicAction_DelayAssignment_1_1 extends AssignmentToken  {
	
	public SymbolicAction_DelayAssignment_1_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getSymbolicActionAccess().getDelayAssignment_1_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("delay",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("delay");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getSymbolicActionAccess().getDelayExpressionParserRuleCall_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 SymbolicAction_AfterKeyword_1_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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

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

}


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


/************ begin Rule ScriptAction ****************
 *
 * ScriptAction:
 * 	script=SCRIPT_STATEMENTS;
 *
 **/

// script=SCRIPT_STATEMENTS
protected class ScriptAction_ScriptAssignment extends AssignmentToken  {
	
	public ScriptAction_ScriptAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getScriptActionAccess().getScriptAssignment();
	}

    @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.getScriptActionRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("script",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("script");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getScriptActionAccess().getScriptSCRIPT_STATEMENTSTerminalRuleCall_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getScriptActionAccess().getScriptSCRIPT_STATEMENTSTerminalRuleCall_0();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule VarDef ****************
 *
 * VarDef:
 * 	"var" name=ID (":" eType=[ecore::EClassifier|QNAME] many?=("*" | "[]")?)? ("=" init=Expression)? ";";
 *
 **/

// "var" name=ID (":" eType=[ecore::EClassifier|QNAME] many?=("*" | "[]")?)? ("=" init=Expression)? ";"
protected class VarDef_Group extends GroupToken {
	
	public VarDef_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getVarDefAccess().getGroup();
	}

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

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

}

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

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

}

// name=ID
protected class VarDef_NameAssignment_1 extends AssignmentToken  {
	
	public VarDef_NameAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getVarDefAccess().getNameAssignment_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("name",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("name");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getVarDefAccess().getNameIDTerminalRuleCall_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getVarDefAccess().getNameIDTerminalRuleCall_1_0();
			return obj;
		}
		return null;
	}

}

// (":" eType=[ecore::EClassifier|QNAME] many?=("*" | "[]")?)?
protected class VarDef_Group_2 extends GroupToken {
	
	public VarDef_Group_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getVarDefAccess().getGroup_2();
	}

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

}

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

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

}

// eType=[ecore::EClassifier|QNAME]
protected class VarDef_ETypeAssignment_2_1 extends AssignmentToken  {
	
	public VarDef_ETypeAssignment_2_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getVarDefAccess().getETypeAssignment_2_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("eType",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("eType");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getVarDefAccess().getETypeEClassifierCrossReference_2_1_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getVarDefAccess().getETypeEClassifierCrossReference_2_1_0(); 
				return obj;
			}
		}
		return null;
	}

}

// many?=("*" | "[]")?
protected class VarDef_ManyAssignment_2_2 extends AssignmentToken  {
	
	public VarDef_ManyAssignment_2_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getVarDefAccess().getManyAssignment_2_2();
	}

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

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

}


// ("=" init=Expression)?
protected class VarDef_Group_3 extends GroupToken {
	
	public VarDef_Group_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getVarDefAccess().getGroup_3();
	}

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

}

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

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

}

// init=Expression
protected class VarDef_InitAssignment_3_1 extends AssignmentToken  {
	
	public VarDef_InitAssignment_3_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getVarDefAccess().getInitAssignment_3_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("init",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("init");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getVarDefAccess().getInitExpressionParserRuleCall_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 VarDef_EqualsSignKeyword_3_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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

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

}


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


/************ begin Rule AssignmentAction ****************
 *
 * AssignmentAction:
 * 	var=[VarDef|QNAME] "=" value=Expression;
 *
 **/

// var=[VarDef|QNAME] "=" value=Expression
protected class AssignmentAction_Group extends GroupToken {
	
	public AssignmentAction_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getAssignmentActionAccess().getGroup();
	}

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

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

}

// var=[VarDef|QNAME]
protected class AssignmentAction_VarAssignment_0 extends AssignmentToken  {
	
	public AssignmentAction_VarAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAssignmentActionAccess().getVarAssignment_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("var",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("var");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getAssignmentActionAccess().getVarVarDefCrossReference_0_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getAssignmentActionAccess().getVarVarDefCrossReference_0_0(); 
				return obj;
			}
		}
		return null;
	}

}

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

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

}

// value=Expression
protected class AssignmentAction_ValueAssignment_2 extends AssignmentToken  {
	
	public AssignmentAction_ValueAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getAssignmentActionAccess().getValueAssignment_2();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("value",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("value");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getAssignmentActionAccess().getValueExpressionParserRuleCall_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 AssignmentAction_EqualsSignKeyword_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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







/************ begin Rule Expression ****************
 *
 * Expression:
 * 	Literal | ScriptExpression | EPath;
 *
 **/

// Literal | ScriptExpression | EPath
protected class Expression_Alternatives extends AlternativesToken {

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

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getBooleanLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getDelayLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEObjectUriLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEPathRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getFloatLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getScriptExpressionRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getStringLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUriLiteralRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// Literal
protected class Expression_LiteralParserRuleCall_0 extends RuleCallToken {
	
	public Expression_LiteralParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getExpressionAccess().getLiteralParserRuleCall_0();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getBooleanLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getDelayLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEObjectUriLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getFloatLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getStringLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUriLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(Literal_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);
		}	
	}	
}

// ScriptExpression
protected class Expression_ScriptExpressionParserRuleCall_1 extends RuleCallToken {
	
	public Expression_ScriptExpressionParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getExpressionAccess().getScriptExpressionParserRuleCall_1();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getScriptExpressionRule().getType().getClassifier())
			return null;
		if(checkForRecursion(ScriptExpression_ScriptAssignment.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);
		}	
	}	
}

// EPath
protected class Expression_EPathParserRuleCall_2 extends RuleCallToken {
	
	public Expression_EPathParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getExpressionAccess().getEPathParserRuleCall_2();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEPathRule().getType().getClassifier())
			return null;
		if(checkForRecursion(EPath_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);
		}	
	}	
}


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


/************ begin Rule Literal ****************
 *
 * Literal:
 * 	BooleanLiteral | FloatLiteral | IntLiteral | StringLiteral | UriLiteral | EObjectUriLiteral | DelayLiteral;
 *
 **/

// BooleanLiteral | FloatLiteral | IntLiteral | StringLiteral | UriLiteral | EObjectUriLiteral | DelayLiteral
protected class Literal_Alternatives extends AlternativesToken {

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

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new Literal_BooleanLiteralParserRuleCall_0(lastRuleCallOrigin, this, 0, inst);
			case 1: return new Literal_FloatLiteralParserRuleCall_1(lastRuleCallOrigin, this, 1, inst);
			case 2: return new Literal_IntLiteralParserRuleCall_2(lastRuleCallOrigin, this, 2, inst);
			case 3: return new Literal_StringLiteralParserRuleCall_3(lastRuleCallOrigin, this, 3, inst);
			case 4: return new Literal_UriLiteralParserRuleCall_4(lastRuleCallOrigin, this, 4, inst);
			case 5: return new Literal_EObjectUriLiteralParserRuleCall_5(lastRuleCallOrigin, this, 5, inst);
			case 6: return new Literal_DelayLiteralParserRuleCall_6(lastRuleCallOrigin, this, 6, inst);
			default: return null;
		}	
	}

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getBooleanLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getDelayLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getEObjectUriLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getFloatLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getIntLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getStringLiteralRule().getType().getClassifier() && 
		   getEObject().eClass() != grammarAccess.getUriLiteralRule().getType().getClassifier())
			return null;
		return eObjectConsumer;
	}

}

// BooleanLiteral
protected class Literal_BooleanLiteralParserRuleCall_0 extends RuleCallToken {
	
	public Literal_BooleanLiteralParserRuleCall_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getBooleanLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(BooleanLiteral_BooleanValueAssignment.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);
		}	
	}	
}

// FloatLiteral
protected class Literal_FloatLiteralParserRuleCall_1 extends RuleCallToken {
	
	public Literal_FloatLiteralParserRuleCall_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralAccess().getFloatLiteralParserRuleCall_1();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getFloatLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(FloatLiteral_FloatValueAssignment.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);
		}	
	}	
}

// IntLiteral
protected class Literal_IntLiteralParserRuleCall_2 extends RuleCallToken {
	
	public Literal_IntLiteralParserRuleCall_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_2();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getIntLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(IntLiteral_IntValueAssignment.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);
		}	
	}	
}

// StringLiteral
protected class Literal_StringLiteralParserRuleCall_3 extends RuleCallToken {
	
	public Literal_StringLiteralParserRuleCall_3(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_3();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getStringLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(StringLiteral_StringValueAssignment.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);
		}	
	}	
}

// UriLiteral
protected class Literal_UriLiteralParserRuleCall_4 extends RuleCallToken {
	
	public Literal_UriLiteralParserRuleCall_4(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralAccess().getUriLiteralParserRuleCall_4();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getUriLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(UriLiteral_UriAssignment.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);
		}	
	}	
}

// EObjectUriLiteral
protected class Literal_EObjectUriLiteralParserRuleCall_5 extends RuleCallToken {
	
	public Literal_EObjectUriLiteralParserRuleCall_5(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralAccess().getEObjectUriLiteralParserRuleCall_5();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEObjectUriLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(EObjectUriLiteral_UriAssignment.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);
		}	
	}	
}

// DelayLiteral
protected class Literal_DelayLiteralParserRuleCall_6 extends RuleCallToken {
	
	public Literal_DelayLiteralParserRuleCall_6(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public RuleCall getGrammarElement() {
		return grammarAccess.getLiteralAccess().getDelayLiteralParserRuleCall_6();
	}

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

    @Override
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getDelayLiteralRule().getType().getClassifier())
			return null;
		if(checkForRecursion(DelayLiteral_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);
		}	
	}	
}


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


/************ begin Rule BooleanLiteral ****************
 *
 * BooleanLiteral:
 * 	booleanValue=BOOLEAN_LITERAL;
 *
 **/

// booleanValue=BOOLEAN_LITERAL
protected class BooleanLiteral_BooleanValueAssignment extends AssignmentToken  {
	
	public BooleanLiteral_BooleanValueAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getBooleanLiteralAccess().getBooleanValueAssignment();
	}

    @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.getBooleanLiteralRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("booleanValue",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("booleanValue");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getBooleanLiteralAccess().getBooleanValueBOOLEAN_LITERALParserRuleCall_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getBooleanLiteralAccess().getBooleanValueBOOLEAN_LITERALParserRuleCall_0();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule IntLiteral ****************
 *
 * IntLiteral:
 * 	intValue=(INT | POS_INT | NEG_INT);
 *
 **/

// intValue=(INT | POS_INT | NEG_INT)
protected class IntLiteral_IntValueAssignment extends AssignmentToken  {
	
	public IntLiteral_IntValueAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getIntLiteralAccess().getIntValueAssignment();
	}

    @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.getIntLiteralRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("intValue",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("intValue");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIntLiteralAccess().getIntValueINTTerminalRuleCall_0_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getIntLiteralAccess().getIntValueINTTerminalRuleCall_0_0();
			return obj;
		}
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIntLiteralAccess().getIntValuePOS_INTParserRuleCall_0_1(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getIntLiteralAccess().getIntValuePOS_INTParserRuleCall_0_1();
			return obj;
		}
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getIntLiteralAccess().getIntValueNEG_INTParserRuleCall_0_2(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getIntLiteralAccess().getIntValueNEG_INTParserRuleCall_0_2();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule FloatLiteral ****************
 *
 * FloatLiteral:
 * 	floatValue=FLOAT_LITERAL;
 *
 **/

// floatValue=FLOAT_LITERAL
protected class FloatLiteral_FloatValueAssignment extends AssignmentToken  {
	
	public FloatLiteral_FloatValueAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getFloatLiteralAccess().getFloatValueAssignment();
	}

    @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.getFloatLiteralRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("floatValue",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("floatValue");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getFloatLiteralAccess().getFloatValueFLOAT_LITERALParserRuleCall_0(), value, null)) {
			type = AssignmentType.DATATYPE_RULE_CALL;
			element = grammarAccess.getFloatLiteralAccess().getFloatValueFLOAT_LITERALParserRuleCall_0();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule StringLiteral ****************
 *
 * StringLiteral:
 * 	stringValue=STRING;
 *
 **/

// stringValue=STRING
protected class StringLiteral_StringValueAssignment extends AssignmentToken  {
	
	public StringLiteral_StringValueAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getStringLiteralAccess().getStringValueAssignment();
	}

    @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.getStringLiteralRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("stringValue",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("stringValue");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getStringLiteralAccess().getStringValueSTRINGTerminalRuleCall_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getStringLiteralAccess().getStringValueSTRINGTerminalRuleCall_0();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule UriLiteral ****************
 *
 * UriLiteral:
 * 	uri=URI_LITERAL;
 *
 **/

// uri=URI_LITERAL
protected class UriLiteral_UriAssignment extends AssignmentToken  {
	
	public UriLiteral_UriAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getUriLiteralAccess().getUriAssignment();
	}

    @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.getUriLiteralRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("uri",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("uri");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getUriLiteralAccess().getUriURI_LITERALTerminalRuleCall_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getUriLiteralAccess().getUriURI_LITERALTerminalRuleCall_0();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule EObjectUriLiteral ****************
 *
 * EObjectUriLiteral:
 * 	uri=EOBJECT_URI_LITERAL;
 *
 **/

// uri=EOBJECT_URI_LITERAL
protected class EObjectUriLiteral_UriAssignment extends AssignmentToken  {
	
	public EObjectUriLiteral_UriAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEObjectUriLiteralAccess().getUriAssignment();
	}

    @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.getEObjectUriLiteralRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("uri",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("uri");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getEObjectUriLiteralAccess().getUriEOBJECT_URI_LITERALTerminalRuleCall_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getEObjectUriLiteralAccess().getUriEOBJECT_URI_LITERALTerminalRuleCall_0();
			return obj;
		}
		return null;
	}

}

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


/************ begin Rule DelayLiteral ****************
 *
 * DelayLiteral:
 * 	intValue=INT timeUnit=TimeUnit;
 *
 **/

// intValue=INT timeUnit=TimeUnit
protected class DelayLiteral_Group extends GroupToken {
	
	public DelayLiteral_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getDelayLiteralAccess().getGroup();
	}

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

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

}

// intValue=INT
protected class DelayLiteral_IntValueAssignment_0 extends AssignmentToken  {
	
	public DelayLiteral_IntValueAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getDelayLiteralAccess().getIntValueAssignment_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("intValue",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("intValue");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getDelayLiteralAccess().getIntValueINTTerminalRuleCall_0_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getDelayLiteralAccess().getIntValueINTTerminalRuleCall_0_0();
			return obj;
		}
		return null;
	}

}

// timeUnit=TimeUnit
protected class DelayLiteral_TimeUnitAssignment_1 extends AssignmentToken  {
	
	public DelayLiteral_TimeUnitAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getDelayLiteralAccess().getTimeUnitAssignment_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("timeUnit",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("timeUnit");
		if(enumLitSerializer.isValid(obj.getEObject(), grammarAccess.getDelayLiteralAccess().getTimeUnitTimeUnitEnumRuleCall_1_0(), value, null)) { 
			type = AssignmentType.ENUM_RULE_CALL;
			element = grammarAccess.getDelayLiteralAccess().getTimeUnitTimeUnitEnumRuleCall_1_0();
			return obj;
		}
		return null;
	}

}


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


/************ begin Rule VarRef ****************
 *
 * VarRef:
 * 	var=[VarDef|QNAME];
 *
 **/

// var=[VarDef|QNAME]
protected class VarRef_VarAssignment extends AssignmentToken  {
	
	public VarRef_VarAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getVarRefAccess().getVarAssignment();
	}

    @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.getVarRefRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("var",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("var");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::CrossReferenceImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getVarRefAccess().getVarVarDefCrossReference_0().getType().getClassifier())) {
				type = AssignmentType.CROSS_REFERENCE;
				element = grammarAccess.getVarRefAccess().getVarVarDefCrossReference_0(); 
				return obj;
			}
		}
		return null;
	}

}

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


/************ begin Rule EPath ****************
 *
 * EPath:
 * 	var=VarRef steps+=EStep*;
 *
 **/

// var=VarRef steps+=EStep*
protected class EPath_Group extends GroupToken {
	
	public EPath_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEPathAccess().getGroup();
	}

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

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

}

// var=VarRef
protected class EPath_VarAssignment_0 extends AssignmentToken  {
	
	public EPath_VarAssignment_0(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEPathAccess().getVarAssignment_0();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("var",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("var");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getVarRefRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEPathAccess().getVarVarRefParserRuleCall_0_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) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
		}	
	}	
}

// steps+=EStep*
protected class EPath_StepsAssignment_1 extends AssignmentToken  {
	
	public EPath_StepsAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEPathAccess().getStepsAssignment_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("steps",false)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("steps");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getEStepRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEPathAccess().getStepsEStepParserRuleCall_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 EPath_StepsAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
			case 1: return new EPath_VarAssignment_0(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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


/************ begin Rule EStep ****************
 *
 * EStep:
 * 	"/ " featureName=ID filter=EStepFilter?;
 *
 **/

// "/ " featureName=ID filter=EStepFilter?
protected class EStep_Group extends GroupToken {
	
	public EStep_Group(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Group getGrammarElement() {
		return grammarAccess.getEStepAccess().getGroup();
	}

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

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

}

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

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

}

// featureName=ID
protected class EStep_FeatureNameAssignment_1 extends AssignmentToken  {
	
	public EStep_FeatureNameAssignment_1(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEStepAccess().getFeatureNameAssignment_1();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if((value = eObjectConsumer.getConsumable("featureName",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("featureName");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getEStepAccess().getFeatureNameIDTerminalRuleCall_1_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getEStepAccess().getFeatureNameIDTerminalRuleCall_1_0();
			return obj;
		}
		return null;
	}

}

// filter=EStepFilter?
protected class EStep_FilterAssignment_2 extends AssignmentToken  {
	
	public EStep_FilterAssignment_2(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEStepAccess().getFilterAssignment_2();
	}

    @Override
	public AbstractToken createFollower(int index, IEObjectConsumer inst) {
		switch(index) {
			case 0: return new EStepFilter_ScriptAssignment(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.getEStepFilterRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEStepAccess().getFilterEStepFilterParserRuleCall_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 EStep_FeatureNameAssignment_1(lastRuleCallOrigin, next, actIndex, consumed);
			default: return null;
		}	
	}	
}


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


/************ begin Rule EStepFilter ****************
 *
 * EStepFilter:
 * 	script=ScriptExpression;
 *
 **/

// script=ScriptExpression
protected class EStepFilter_ScriptAssignment extends AssignmentToken  {
	
	public EStepFilter_ScriptAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getEStepFilterAccess().getScriptAssignment();
	}

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

    @Override	
	public IEObjectConsumer tryConsume() {
		if(getEObject().eClass() != grammarAccess.getEStepFilterRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("script",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("script");
		if(value instanceof EObject) { // org::eclipse::xtext::impl::RuleCallImpl
			IEObjectConsumer param = createEObjectConsumer((EObject)value);
			if(param.isInstanceOf(grammarAccess.getScriptExpressionRule().getType().getClassifier())) {
				type = AssignmentType.PARSER_RULE_CALL;
				element = grammarAccess.getEStepFilterAccess().getScriptScriptExpressionParserRuleCall_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) {
			default: return lastRuleCallOrigin.createFollowerAfterReturn(next, actIndex , index, consumed);
		}	
	}	
}

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


/************ begin Rule ScriptExpression ****************
 *
 * ScriptExpression:
 * 	script=SCRIPT_EXPRESSION;
 *
 **/

// script=SCRIPT_EXPRESSION
protected class ScriptExpression_ScriptAssignment extends AssignmentToken  {
	
	public ScriptExpression_ScriptAssignment(AbstractToken lastRuleCallOrigin, AbstractToken next, int transitionIndex, IEObjectConsumer eObjectConsumer) {
		super(lastRuleCallOrigin, next, transitionIndex, eObjectConsumer);
	}
	
	@Override
	public Assignment getGrammarElement() {
		return grammarAccess.getScriptExpressionAccess().getScriptAssignment();
	}

    @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.getScriptExpressionRule().getType().getClassifier())
			return null;
		if((value = eObjectConsumer.getConsumable("script",true)) == null) return null;
		IEObjectConsumer obj = eObjectConsumer.cloneAndConsume("script");
		if(valueSerializer.isValid(obj.getEObject(), grammarAccess.getScriptExpressionAccess().getScriptSCRIPT_EXPRESSIONTerminalRuleCall_0(), value, null)) {
			type = AssignmentType.TERMINAL_RULE_CALL;
			element = grammarAccess.getScriptExpressionAccess().getScriptSCRIPT_EXPRESSIONTerminalRuleCall_0();
			return obj;
		}
		return null;
	}

}

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

}