org.eclipse.osbp.xtext.statemachine/src-gen/org/eclipse/osbp/xtext/statemachine/serializer/StatemachineDSLSemanticSequencer.java

/**
 *                                                                            
 *  Copyright (c) 2011, 2017 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
 *                                                                            
 *  All rights reserved. This program and the accompanying materials           
 *  are made available under the terms of the Eclipse Public License 2.0        
 *  which accompanies this distribution, and is available at                  
 *  https://www.eclipse.org/legal/epl-2.0/                                 
 *                                 
 *  SPDX-License-Identifier: EPL-2.0                                 
 *                                                                            
 *  Contributors:                                                      
 * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 * 
 * generated by Xtext 2.11.0
 *
 */

package org.eclipse.osbp.xtext.statemachine.serializer;

import com.google.inject.Inject;
import java.util.Set;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration;
import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage;
import org.eclipse.osbp.xtext.oxtype.serializer.OXtypeSemanticSequencer;
import org.eclipse.osbp.xtext.statemachine.FSM;
import org.eclipse.osbp.xtext.statemachine.FSMActionButtonCaption;
import org.eclipse.osbp.xtext.statemachine.FSMActionButtonImage;
import org.eclipse.osbp.xtext.statemachine.FSMActionConditionalTransition;
import org.eclipse.osbp.xtext.statemachine.FSMActionDTOClear;
import org.eclipse.osbp.xtext.statemachine.FSMActionDTOFind;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldClear;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldConcatenation;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldFilterToggle;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldGet;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldRemove;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSet;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSourceBoolean;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSourceDtoAttribute;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSourceEvaluate;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSourceEvent;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSourceInteger;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSourceNumber;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSourceString;
import org.eclipse.osbp.xtext.statemachine.FSMActionFieldSourceTranslate;
import org.eclipse.osbp.xtext.statemachine.FSMActionItemInvisible;
import org.eclipse.osbp.xtext.statemachine.FSMActionItemVisible;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralBeeper;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralBlinkRate;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralClear;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralCreateWindow;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralCursorType;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralDestroyWindow;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralDeviceBrightness;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralDisplayText;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralInterCharacterWait;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralLineDisplayText;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralLineDisplayTextAt;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralMarqueeFormat;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralMarqueeRepeatWait;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralMarqueeType;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralMarqueeUnitWait;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralOpenDrawer;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPTAcknowledge;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPTAuthorization;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPTClose;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPTOpen;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPTRegistration;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPTResponse;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPTReversal;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPlayer;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPrintBarcode;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPrintBitmap;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPrintCut;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPrintNormal;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralPrintReport;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralScaleDisplayText;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralScaleReadTareWeight;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralScaleReadWeight;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralScaleTareWeight;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralScaleWeightUnit;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralScaleZero;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralScroll;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralSignatureCapture;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralSignatureClear;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralSignatureClose;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralSignatureIdle;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralSignatureLabel;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralSignatureOpen;
import org.eclipse.osbp.xtext.statemachine.FSMActionPeripheralSound;
import org.eclipse.osbp.xtext.statemachine.FSMActionScheduler;
import org.eclipse.osbp.xtext.statemachine.FSMAndFilter;
import org.eclipse.osbp.xtext.statemachine.FSMBetweenFilter;
import org.eclipse.osbp.xtext.statemachine.FSMCompareFilter;
import org.eclipse.osbp.xtext.statemachine.FSMControlButton;
import org.eclipse.osbp.xtext.statemachine.FSMControlButtonAttribute;
import org.eclipse.osbp.xtext.statemachine.FSMControlButtonAttributeEventEvent;
import org.eclipse.osbp.xtext.statemachine.FSMControlButtonAttributeEventIdentity;
import org.eclipse.osbp.xtext.statemachine.FSMControlButtonAttributeEventKeyboard;
import org.eclipse.osbp.xtext.statemachine.FSMControlDTO;
import org.eclipse.osbp.xtext.statemachine.FSMControlDTOAttribute;
import org.eclipse.osbp.xtext.statemachine.FSMControlField;
import org.eclipse.osbp.xtext.statemachine.FSMControlFieldAttribute;
import org.eclipse.osbp.xtext.statemachine.FSMControlFieldLayout;
import org.eclipse.osbp.xtext.statemachine.FSMControlFilter;
import org.eclipse.osbp.xtext.statemachine.FSMControlPeripheral;
import org.eclipse.osbp.xtext.statemachine.FSMControlScheduler;
import org.eclipse.osbp.xtext.statemachine.FSMControlSchedulerAttribute;
import org.eclipse.osbp.xtext.statemachine.FSMDTOType;
import org.eclipse.osbp.xtext.statemachine.FSMDotExpression;
import org.eclipse.osbp.xtext.statemachine.FSMDtoRef;
import org.eclipse.osbp.xtext.statemachine.FSMEvent;
import org.eclipse.osbp.xtext.statemachine.FSMFieldType;
import org.eclipse.osbp.xtext.statemachine.FSMFilter;
import org.eclipse.osbp.xtext.statemachine.FSMFilterProperty;
import org.eclipse.osbp.xtext.statemachine.FSMFunction;
import org.eclipse.osbp.xtext.statemachine.FSMGuard;
import org.eclipse.osbp.xtext.statemachine.FSMIsNullFilter;
import org.eclipse.osbp.xtext.statemachine.FSMKeyMapper;
import org.eclipse.osbp.xtext.statemachine.FSMLikeFilter;
import org.eclipse.osbp.xtext.statemachine.FSMModel;
import org.eclipse.osbp.xtext.statemachine.FSMNotFilter;
import org.eclipse.osbp.xtext.statemachine.FSMOperation;
import org.eclipse.osbp.xtext.statemachine.FSMOperationParameter;
import org.eclipse.osbp.xtext.statemachine.FSMOrFilter;
import org.eclipse.osbp.xtext.statemachine.FSMPackage;
import org.eclipse.osbp.xtext.statemachine.FSMPeripheralDeviceCashDrawer;
import org.eclipse.osbp.xtext.statemachine.FSMPeripheralDeviceDisplay;
import org.eclipse.osbp.xtext.statemachine.FSMPeripheralDeviceLineDisplay;
import org.eclipse.osbp.xtext.statemachine.FSMPeripheralDevicePOSPrinter;
import org.eclipse.osbp.xtext.statemachine.FSMPeripheralDevicePT;
import org.eclipse.osbp.xtext.statemachine.FSMPeripheralDeviceScale;
import org.eclipse.osbp.xtext.statemachine.FSMPeripheralDeviceSignature;
import org.eclipse.osbp.xtext.statemachine.FSMSignatureRetrieve;
import org.eclipse.osbp.xtext.statemachine.FSMState;
import org.eclipse.osbp.xtext.statemachine.FSMStorage;
import org.eclipse.osbp.xtext.statemachine.FSMStorageRetrieve;
import org.eclipse.osbp.xtext.statemachine.FSMStringFilter;
import org.eclipse.osbp.xtext.statemachine.FSMTrigger;
import org.eclipse.osbp.xtext.statemachine.StatemachineDSLPackage;
import org.eclipse.osbp.xtext.statemachine.services.StatemachineDSLGrammarAccess;
import org.eclipse.xtext.Action;
import org.eclipse.xtext.Parameter;
import org.eclipse.xtext.ParserRule;
import org.eclipse.xtext.common.types.JvmFormalParameter;
import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference;
import org.eclipse.xtext.common.types.JvmInnerTypeReference;
import org.eclipse.xtext.common.types.JvmLowerBound;
import org.eclipse.xtext.common.types.JvmParameterizedTypeReference;
import org.eclipse.xtext.common.types.JvmTypeParameter;
import org.eclipse.xtext.common.types.JvmUpperBound;
import org.eclipse.xtext.common.types.JvmWildcardTypeReference;
import org.eclipse.xtext.common.types.TypesPackage;
import org.eclipse.xtext.serializer.ISerializationContext;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
import org.eclipse.xtext.xbase.XAssignment;
import org.eclipse.xtext.xbase.XBasicForLoopExpression;
import org.eclipse.xtext.xbase.XBinaryOperation;
import org.eclipse.xtext.xbase.XBlockExpression;
import org.eclipse.xtext.xbase.XBooleanLiteral;
import org.eclipse.xtext.xbase.XCasePart;
import org.eclipse.xtext.xbase.XCastedExpression;
import org.eclipse.xtext.xbase.XCatchClause;
import org.eclipse.xtext.xbase.XClosure;
import org.eclipse.xtext.xbase.XConstructorCall;
import org.eclipse.xtext.xbase.XDoWhileExpression;
import org.eclipse.xtext.xbase.XFeatureCall;
import org.eclipse.xtext.xbase.XForLoopExpression;
import org.eclipse.xtext.xbase.XIfExpression;
import org.eclipse.xtext.xbase.XInstanceOfExpression;
import org.eclipse.xtext.xbase.XListLiteral;
import org.eclipse.xtext.xbase.XMemberFeatureCall;
import org.eclipse.xtext.xbase.XNullLiteral;
import org.eclipse.xtext.xbase.XNumberLiteral;
import org.eclipse.xtext.xbase.XPostfixOperation;
import org.eclipse.xtext.xbase.XReturnExpression;
import org.eclipse.xtext.xbase.XSetLiteral;
import org.eclipse.xtext.xbase.XStringLiteral;
import org.eclipse.xtext.xbase.XSwitchExpression;
import org.eclipse.xtext.xbase.XSynchronizedExpression;
import org.eclipse.xtext.xbase.XThrowExpression;
import org.eclipse.xtext.xbase.XTryCatchFinallyExpression;
import org.eclipse.xtext.xbase.XTypeLiteral;
import org.eclipse.xtext.xbase.XUnaryOperation;
import org.eclipse.xtext.xbase.XVariableDeclaration;
import org.eclipse.xtext.xbase.XWhileExpression;
import org.eclipse.xtext.xbase.XbasePackage;
import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotation;
import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotationElementValuePair;
import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotationsPackage;
import org.eclipse.xtext.xtype.XFunctionTypeRef;
import org.eclipse.xtext.xtype.XImportSection;
import org.eclipse.xtext.xtype.XtypePackage;

@SuppressWarnings("all")
public class StatemachineDSLSemanticSequencer extends OXtypeSemanticSequencer {

	@Inject
	private StatemachineDSLGrammarAccess grammarAccess;
	
	@Override
	public void sequence(ISerializationContext context, EObject semanticObject) {
		EPackage epackage = semanticObject.eClass().getEPackage();
		ParserRule rule = context.getParserRule();
		Action action = context.getAssignedAction();
		Set<Parameter> parameters = context.getEnabledBooleanParameters();
		if (epackage == OXtypePackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case OXtypePackage.OX_IMPORT_DECLARATION:
				sequence_XImportDeclaration(context, (OXImportDeclaration) semanticObject); 
				return; 
			}
		else if (epackage == StatemachineDSLPackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case StatemachineDSLPackage.FSM:
				sequence_FSM(context, (FSM) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_BUTTON_CAPTION:
				sequence_FSMActionButtonCaption(context, (FSMActionButtonCaption) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_BUTTON_IMAGE:
				sequence_FSMActionButtonImage(context, (FSMActionButtonImage) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_CONDITIONAL_TRANSITION:
				sequence_FSMActionConditionalTransition(context, (FSMActionConditionalTransition) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_DTO_CLEAR:
				sequence_FSMActionDTOClear(context, (FSMActionDTOClear) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_DTO_FIND:
				sequence_FSMActionDTOFind(context, (FSMActionDTOFind) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_FIELD_CLEAR:
				sequence_FSMActionFieldClear(context, (FSMActionFieldClear) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_FIELD_CONCATENATION:
				sequence_FSMActionFieldConcatenation(context, (FSMActionFieldConcatenation) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_FIELD_FILTER_TOGGLE:
				sequence_FSMActionFieldFilterToggle(context, (FSMActionFieldFilterToggle) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_FIELD_GET:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMActionFieldGetMoreRule()) {
					sequence_FSMActionFieldGetMore(context, (FSMActionFieldGet) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMActionFieldGetRule()) {
					sequence_FSMActionFieldGet(context, (FSMActionFieldGet) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_ACTION_FIELD_REMOVE:
				sequence_FSMActionFieldRemove(context, (FSMActionFieldRemove) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SET:
				sequence_FSMActionFieldSet(context, (FSMActionFieldSet) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SOURCE_BOOLEAN:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMActionFieldSourceBooleanMoreRule()) {
					sequence_FSMActionFieldSourceBooleanMore(context, (FSMActionFieldSourceBoolean) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMActionFieldSourceBooleanRule()) {
					sequence_FSMActionFieldSourceBoolean(context, (FSMActionFieldSourceBoolean) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMActionFieldSourceDtoAttributeMoreRule()) {
					sequence_FSMActionFieldSourceDtoAttributeMore(context, (FSMActionFieldSourceDtoAttribute) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMActionFieldSourceDtoAttributeRule()) {
					sequence_FSMActionFieldSourceDtoAttribute(context, (FSMActionFieldSourceDtoAttribute) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SOURCE_EVALUATE:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMActionFieldSourceEvaluateMoreRule()) {
					sequence_FSMActionFieldSourceEvaluateMore(context, (FSMActionFieldSourceEvaluate) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMActionFieldSourceEvaluateRule()) {
					sequence_FSMActionFieldSourceEvaluate(context, (FSMActionFieldSourceEvaluate) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SOURCE_EVENT:
				sequence_FSMActionFieldSourceEvent(context, (FSMActionFieldSourceEvent) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SOURCE_INTEGER:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMActionFieldSourceIntegerMoreRule()) {
					sequence_FSMActionFieldSourceIntegerMore(context, (FSMActionFieldSourceInteger) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMActionFieldSourceIntegerRule()) {
					sequence_FSMActionFieldSourceInteger(context, (FSMActionFieldSourceInteger) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SOURCE_NUMBER:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMActionFieldSourceNumberMoreRule()) {
					sequence_FSMActionFieldSourceNumberMore(context, (FSMActionFieldSourceNumber) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMActionFieldSourceNumberRule()) {
					sequence_FSMActionFieldSourceNumber(context, (FSMActionFieldSourceNumber) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SOURCE_STRING:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMActionFieldSourceStringMoreRule()) {
					sequence_FSMActionFieldSourceStringMore(context, (FSMActionFieldSourceString) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMActionFieldSourceStringRule()) {
					sequence_FSMActionFieldSourceString(context, (FSMActionFieldSourceString) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_ACTION_FIELD_SOURCE_TRANSLATE:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMActionFieldSourceTranslateMoreRule()) {
					sequence_FSMActionFieldSourceTranslateMore(context, (FSMActionFieldSourceTranslate) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMActionFieldSourceTranslateRule()) {
					sequence_FSMActionFieldSourceTranslate(context, (FSMActionFieldSourceTranslate) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_ACTION_ITEM_INVISIBLE:
				sequence_FSMActionItemInvisible(context, (FSMActionItemInvisible) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_ITEM_VISIBLE:
				sequence_FSMActionItemVisible(context, (FSMActionItemVisible) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_BEEPER:
				sequence_FSMActionPeripheralBeeper(context, (FSMActionPeripheralBeeper) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_BLINK_RATE:
				sequence_FSMActionPeripheralBlinkRate(context, (FSMActionPeripheralBlinkRate) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_CLEAR:
				sequence_FSMActionPeripheralClear(context, (FSMActionPeripheralClear) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_CREATE_WINDOW:
				sequence_FSMActionPeripheralCreateWindow(context, (FSMActionPeripheralCreateWindow) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_CURSOR_TYPE:
				sequence_FSMActionPeripheralCursorType(context, (FSMActionPeripheralCursorType) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_DESTROY_WINDOW:
				sequence_FSMActionPeripheralDestroyWindow(context, (FSMActionPeripheralDestroyWindow) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_DEVICE_BRIGHTNESS:
				sequence_FSMActionPeripheralDeviceBrightness(context, (FSMActionPeripheralDeviceBrightness) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT:
				sequence_FSMActionPeripheralDisplayText(context, (FSMActionPeripheralDisplayText) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_INTER_CHARACTER_WAIT:
				sequence_FSMActionPeripheralInterCharacterWait(context, (FSMActionPeripheralInterCharacterWait) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_LINE_DISPLAY_TEXT:
				sequence_FSMActionPeripheralLineDisplayText(context, (FSMActionPeripheralLineDisplayText) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_LINE_DISPLAY_TEXT_AT:
				sequence_FSMActionPeripheralLineDisplayTextAt(context, (FSMActionPeripheralLineDisplayTextAt) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_MARQUEE_FORMAT:
				sequence_FSMActionPeripheralMarqueeFormat(context, (FSMActionPeripheralMarqueeFormat) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_MARQUEE_REPEAT_WAIT:
				sequence_FSMActionPeripheralMarqueeRepeatWait(context, (FSMActionPeripheralMarqueeRepeatWait) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_MARQUEE_TYPE:
				sequence_FSMActionPeripheralMarqueeType(context, (FSMActionPeripheralMarqueeType) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_MARQUEE_UNIT_WAIT:
				sequence_FSMActionPeripheralMarqueeUnitWait(context, (FSMActionPeripheralMarqueeUnitWait) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_OPEN_DRAWER:
				sequence_FSMActionPeripheralOpenDrawer(context, (FSMActionPeripheralOpenDrawer) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PT_ACKNOWLEDGE:
				sequence_FSMActionPeripheralPTAcknowledge(context, (FSMActionPeripheralPTAcknowledge) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PT_AUTHORIZATION:
				sequence_FSMActionPeripheralPTAuthorization(context, (FSMActionPeripheralPTAuthorization) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PT_CLOSE:
				sequence_FSMActionPeripheralPTClose(context, (FSMActionPeripheralPTClose) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PT_OPEN:
				sequence_FSMActionPeripheralPTOpen(context, (FSMActionPeripheralPTOpen) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PT_REGISTRATION:
				sequence_FSMActionPeripheralPTRegistration(context, (FSMActionPeripheralPTRegistration) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PT_RESPONSE:
				sequence_FSMActionPeripheralPTResponse(context, (FSMActionPeripheralPTResponse) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PT_REVERSAL:
				sequence_FSMActionPeripheralPTReversal(context, (FSMActionPeripheralPTReversal) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PLAYER:
				sequence_FSMActionPeripheralPlayer(context, (FSMActionPeripheralPlayer) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PRINT_BARCODE:
				sequence_FSMActionPeripheralPrintBarcode(context, (FSMActionPeripheralPrintBarcode) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PRINT_BITMAP:
				sequence_FSMActionPeripheralPrintBitmap(context, (FSMActionPeripheralPrintBitmap) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PRINT_CUT:
				sequence_FSMActionPeripheralPrintCut(context, (FSMActionPeripheralPrintCut) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PRINT_NORMAL:
				sequence_FSMActionPeripheralPrintNormal(context, (FSMActionPeripheralPrintNormal) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_PRINT_REPORT:
				sequence_FSMActionPeripheralPrintReport(context, (FSMActionPeripheralPrintReport) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SCALE_DISPLAY_TEXT:
				sequence_FSMActionPeripheralScaleDisplayText(context, (FSMActionPeripheralScaleDisplayText) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SCALE_READ_TARE_WEIGHT:
				sequence_FSMActionPeripheralScaleReadTareWeight(context, (FSMActionPeripheralScaleReadTareWeight) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SCALE_READ_WEIGHT:
				sequence_FSMActionPeripheralScaleReadWeight(context, (FSMActionPeripheralScaleReadWeight) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SCALE_TARE_WEIGHT:
				sequence_FSMActionPeripheralScaleTareWeight(context, (FSMActionPeripheralScaleTareWeight) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SCALE_WEIGHT_UNIT:
				sequence_FSMActionPeripheralScaleWeightUnit(context, (FSMActionPeripheralScaleWeightUnit) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SCALE_ZERO:
				sequence_FSMActionPeripheralScaleZero(context, (FSMActionPeripheralScaleZero) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SCROLL:
				sequence_FSMActionPeripheralScroll(context, (FSMActionPeripheralScroll) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SIGNATURE_CAPTURE:
				sequence_FSMActionPeripheralSignatureCapture(context, (FSMActionPeripheralSignatureCapture) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SIGNATURE_CLEAR:
				sequence_FSMActionPeripheralSignatureClear(context, (FSMActionPeripheralSignatureClear) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SIGNATURE_CLOSE:
				sequence_FSMActionPeripheralSignatureClose(context, (FSMActionPeripheralSignatureClose) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SIGNATURE_IDLE:
				sequence_FSMActionPeripheralSignatureIdle(context, (FSMActionPeripheralSignatureIdle) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL:
				sequence_FSMActionPeripheralSignatureLabel(context, (FSMActionPeripheralSignatureLabel) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SIGNATURE_OPEN:
				sequence_FSMActionPeripheralSignatureOpen(context, (FSMActionPeripheralSignatureOpen) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_PERIPHERAL_SOUND:
				sequence_FSMActionPeripheralSound(context, (FSMActionPeripheralSound) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_ACTION_SCHEDULER:
				sequence_FSMActionScheduler(context, (FSMActionScheduler) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_AND_FILTER:
				sequence_FSMAndFilter(context, (FSMAndFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_BETWEEN_FILTER:
				sequence_FSMBetweenFilter(context, (FSMBetweenFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_COMPARE_FILTER:
				sequence_FSMCompareFilter(context, (FSMCompareFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_BUTTON:
				sequence_FSMControlButton(context, (FSMControlButton) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_BUTTON_ATTRIBUTE:
				sequence_FSMControlButtonAttribute(context, (FSMControlButtonAttribute) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_EVENT:
				sequence_FSMControlButtonAttributeEventEvent(context, (FSMControlButtonAttributeEventEvent) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_IDENTITY:
				sequence_FSMControlButtonAttributeEventIdentity(context, (FSMControlButtonAttributeEventIdentity) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_KEYBOARD:
				sequence_FSMControlButtonAttributeEventKeyboard(context, (FSMControlButtonAttributeEventKeyboard) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_DTO:
				sequence_FSMControlDTO(context, (FSMControlDTO) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_DTO_ATTRIBUTE:
				sequence_FSMControlDTOAttribute(context, (FSMControlDTOAttribute) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_FIELD:
				sequence_FSMControlField(context, (FSMControlField) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_FIELD_ATTRIBUTE:
				sequence_FSMControlFieldAttribute(context, (FSMControlFieldAttribute) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_FIELD_LAYOUT:
				sequence_FSMControlFieldLayout(context, (FSMControlFieldLayout) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_FILTER:
				sequence_FSMControlFilter(context, (FSMControlFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_PERIPHERAL:
				sequence_FSMControlPeripheral(context, (FSMControlPeripheral) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_SCHEDULER:
				sequence_FSMControlScheduler(context, (FSMControlScheduler) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_CONTROL_SCHEDULER_ATTRIBUTE:
				sequence_FSMControlSchedulerAttribute(context, (FSMControlSchedulerAttribute) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSMDTO_TYPE:
				sequence_FSMDTOType(context, (FSMDTOType) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_DOT_EXPRESSION:
				sequence_FSMDotExpression(context, (FSMDotExpression) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_DTO_REF:
				sequence_FSMDtoRef(context, (FSMDtoRef) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_EVENT:
				sequence_FSMEvent(context, (FSMEvent) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_FIELD_TYPE:
				sequence_FSMFieldType(context, (FSMFieldType) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_FILTER:
				if (rule == grammarAccess.getFSMFilterMoreRule()) {
					sequence_FSMFilterMore(context, (FSMFilter) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMFilterRule()) {
					sequence_FSMFilter(context, (FSMFilter) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_FILTER_PROPERTY:
				sequence_FSMFilterProperty(context, (FSMFilterProperty) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_FUNCTION:
				sequence_FSMFunction(context, (FSMFunction) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_GUARD:
				sequence_FSMGuard(context, (FSMGuard) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_IS_NULL_FILTER:
				sequence_FSMIsNullFilter(context, (FSMIsNullFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_KEY_MAPPER:
				sequence_FSMKeyMapper(context, (FSMKeyMapper) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_LIKE_FILTER:
				sequence_FSMLikeFilter(context, (FSMLikeFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_MODEL:
				sequence_FSMModel(context, (FSMModel) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_NOT_FILTER:
				sequence_FSMNotFilter(context, (FSMNotFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_OPERATION:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMOperationMoreRule()) {
					sequence_FSMOperationMore(context, (FSMOperation) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionRule()
						|| rule == grammarAccess.getFSMOperationRule()) {
					sequence_FSMOperation(context, (FSMOperation) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_OPERATION_PARAMETER:
				if (rule == grammarAccess.getFSMOperationParameterMoreRule()) {
					sequence_FSMOperationParameterMore(context, (FSMOperationParameter) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMOperationParameterRule()) {
					sequence_FSMOperationParameter(context, (FSMOperationParameter) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_OR_FILTER:
				sequence_FSMOrFilter(context, (FSMOrFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_PACKAGE:
				sequence_FSMPackage(context, (FSMPackage) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_PERIPHERAL_DEVICE_CASH_DRAWER:
				sequence_FSMPeripheralDeviceCashDrawer(context, (FSMPeripheralDeviceCashDrawer) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_PERIPHERAL_DEVICE_DISPLAY:
				sequence_FSMPeripheralDeviceDisplay(context, (FSMPeripheralDeviceDisplay) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_PERIPHERAL_DEVICE_LINE_DISPLAY:
				sequence_FSMPeripheralDeviceLineDisplay(context, (FSMPeripheralDeviceLineDisplay) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_PERIPHERAL_DEVICE_POS_PRINTER:
				sequence_FSMPeripheralDevicePOSPrinter(context, (FSMPeripheralDevicePOSPrinter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_PERIPHERAL_DEVICE_PT:
				sequence_FSMPeripheralDevicePT(context, (FSMPeripheralDevicePT) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_PERIPHERAL_DEVICE_SCALE:
				sequence_FSMPeripheralDeviceScale(context, (FSMPeripheralDeviceScale) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_PERIPHERAL_DEVICE_SIGNATURE:
				sequence_FSMPeripheralDeviceSignature(context, (FSMPeripheralDeviceSignature) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_SIGNATURE_RETRIEVE:
				sequence_FSMSignatureRetrieve(context, (FSMSignatureRetrieve) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_STATE:
				sequence_FSMState(context, (FSMState) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_STORAGE:
				sequence_FSMStorage(context, (FSMStorage) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_STORAGE_RETRIEVE:
				if (rule == grammarAccess.getFSMActionFieldSourceMoreRule()
						|| rule == grammarAccess.getFSMStorageRetrieveMoreRule()) {
					sequence_FSMStorageRetrieveMore(context, (FSMStorageRetrieve) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getFSMActionFieldSourceRule()
						|| rule == grammarAccess.getFSMStorageRetrieveRule()) {
					sequence_FSMStorageRetrieve(context, (FSMStorageRetrieve) semanticObject); 
					return; 
				}
				else break;
			case StatemachineDSLPackage.FSM_STRING_FILTER:
				sequence_FSMStringFilter(context, (FSMStringFilter) semanticObject); 
				return; 
			case StatemachineDSLPackage.FSM_TRIGGER:
				sequence_FSMTrigger(context, (FSMTrigger) semanticObject); 
				return; 
			}
		else if (epackage == TypesPackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case TypesPackage.JVM_FORMAL_PARAMETER:
				if (rule == grammarAccess.getFullJvmFormalParameterRule()) {
					sequence_FullJvmFormalParameter(context, (JvmFormalParameter) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getJvmFormalParameterRule()) {
					sequence_JvmFormalParameter(context, (JvmFormalParameter) semanticObject); 
					return; 
				}
				else break;
			case TypesPackage.JVM_GENERIC_ARRAY_TYPE_REFERENCE:
				sequence_JvmTypeReference(context, (JvmGenericArrayTypeReference) semanticObject); 
				return; 
			case TypesPackage.JVM_INNER_TYPE_REFERENCE:
				sequence_JvmParameterizedTypeReference(context, (JvmInnerTypeReference) semanticObject); 
				return; 
			case TypesPackage.JVM_LOWER_BOUND:
				if (rule == grammarAccess.getJvmLowerBoundAndedRule()) {
					sequence_JvmLowerBoundAnded(context, (JvmLowerBound) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getJvmLowerBoundRule()) {
					sequence_JvmLowerBound(context, (JvmLowerBound) semanticObject); 
					return; 
				}
				else break;
			case TypesPackage.JVM_PARAMETERIZED_TYPE_REFERENCE:
				if (action == grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()) {
					sequence_JvmParameterizedTypeReference_JvmInnerTypeReference_1_4_0_0_0(context, (JvmParameterizedTypeReference) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getJvmTypeReferenceRule()
						|| action == grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()
						|| rule == grammarAccess.getJvmParameterizedTypeReferenceRule()
						|| rule == grammarAccess.getJvmArgumentTypeReferenceRule()) {
					sequence_JvmParameterizedTypeReference(context, (JvmParameterizedTypeReference) semanticObject); 
					return; 
				}
				else break;
			case TypesPackage.JVM_TYPE_PARAMETER:
				sequence_JvmTypeParameter(context, (JvmTypeParameter) semanticObject); 
				return; 
			case TypesPackage.JVM_UPPER_BOUND:
				if (rule == grammarAccess.getJvmUpperBoundAndedRule()) {
					sequence_JvmUpperBoundAnded(context, (JvmUpperBound) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getJvmUpperBoundRule()) {
					sequence_JvmUpperBound(context, (JvmUpperBound) semanticObject); 
					return; 
				}
				else break;
			case TypesPackage.JVM_WILDCARD_TYPE_REFERENCE:
				sequence_JvmWildcardTypeReference(context, (JvmWildcardTypeReference) semanticObject); 
				return; 
			}
		else if (epackage == XAnnotationsPackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case XAnnotationsPackage.XANNOTATION:
				sequence_XAnnotation(context, (XAnnotation) semanticObject); 
				return; 
			case XAnnotationsPackage.XANNOTATION_ELEMENT_VALUE_PAIR:
				sequence_XAnnotationElementValuePair(context, (XAnnotationElementValuePair) semanticObject); 
				return; 
			}
		else if (epackage == XbasePackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case XbasePackage.XASSIGNMENT:
				sequence_XAssignment_XMemberFeatureCall(context, (XAssignment) semanticObject); 
				return; 
			case XbasePackage.XBASIC_FOR_LOOP_EXPRESSION:
				sequence_XBasicForLoopExpression(context, (XBasicForLoopExpression) semanticObject); 
				return; 
			case XbasePackage.XBINARY_OPERATION:
				sequence_XAdditiveExpression_XAndExpression_XAssignment_XEqualityExpression_XMultiplicativeExpression_XOrExpression_XOtherOperatorExpression_XRelationalExpression(context, (XBinaryOperation) semanticObject); 
				return; 
			case XbasePackage.XBLOCK_EXPRESSION:
				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()
						|| action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
						|| rule == grammarAccess.getXAnnotationElementValueRule()
						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
						|| rule == grammarAccess.getXExpressionRule()
						|| rule == grammarAccess.getXAssignmentRule()
						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOrExpressionRule()
						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAndExpressionRule()
						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXEqualityExpressionRule()
						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXRelationalExpressionRule()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAdditiveExpressionRule()
						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXUnaryOperationRule()
						|| rule == grammarAccess.getXCastedExpressionRule()
						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
						|| rule == grammarAccess.getXPostfixOperationRule()
						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
						|| rule == grammarAccess.getXMemberFeatureCallRule()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
						|| rule == grammarAccess.getXPrimaryExpressionRule()
						|| rule == grammarAccess.getXParenthesizedExpressionRule()
						|| rule == grammarAccess.getXBlockExpressionRule()
						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
					sequence_XBlockExpression(context, (XBlockExpression) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getXExpressionInClosureRule()) {
					sequence_XExpressionInClosure(context, (XBlockExpression) semanticObject); 
					return; 
				}
				else break;
			case XbasePackage.XBOOLEAN_LITERAL:
				sequence_XBooleanLiteral(context, (XBooleanLiteral) semanticObject); 
				return; 
			case XbasePackage.XCASE_PART:
				sequence_XCasePart(context, (XCasePart) semanticObject); 
				return; 
			case XbasePackage.XCASTED_EXPRESSION:
				sequence_XCastedExpression(context, (XCastedExpression) semanticObject); 
				return; 
			case XbasePackage.XCATCH_CLAUSE:
				sequence_XCatchClause(context, (XCatchClause) semanticObject); 
				return; 
			case XbasePackage.XCLOSURE:
				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()
						|| action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
						|| rule == grammarAccess.getXAnnotationElementValueRule()
						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
						|| rule == grammarAccess.getXExpressionRule()
						|| rule == grammarAccess.getXAssignmentRule()
						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOrExpressionRule()
						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAndExpressionRule()
						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXEqualityExpressionRule()
						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXRelationalExpressionRule()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAdditiveExpressionRule()
						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXUnaryOperationRule()
						|| rule == grammarAccess.getXCastedExpressionRule()
						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
						|| rule == grammarAccess.getXPostfixOperationRule()
						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
						|| rule == grammarAccess.getXMemberFeatureCallRule()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
						|| rule == grammarAccess.getXPrimaryExpressionRule()
						|| rule == grammarAccess.getXLiteralRule()
						|| rule == grammarAccess.getXClosureRule()
						|| rule == grammarAccess.getXParenthesizedExpressionRule()
						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
					sequence_XClosure(context, (XClosure) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getXShortClosureRule()) {
					sequence_XShortClosure(context, (XClosure) semanticObject); 
					return; 
				}
				else break;
			case XbasePackage.XCONSTRUCTOR_CALL:
				sequence_XConstructorCall(context, (XConstructorCall) semanticObject); 
				return; 
			case XbasePackage.XDO_WHILE_EXPRESSION:
				sequence_XDoWhileExpression(context, (XDoWhileExpression) semanticObject); 
				return; 
			case XbasePackage.XFEATURE_CALL:
				sequence_XFeatureCall(context, (XFeatureCall) semanticObject); 
				return; 
			case XbasePackage.XFOR_LOOP_EXPRESSION:
				sequence_XForLoopExpression(context, (XForLoopExpression) semanticObject); 
				return; 
			case XbasePackage.XIF_EXPRESSION:
				sequence_XIfExpression(context, (XIfExpression) semanticObject); 
				return; 
			case XbasePackage.XINSTANCE_OF_EXPRESSION:
				sequence_XRelationalExpression(context, (XInstanceOfExpression) semanticObject); 
				return; 
			case XbasePackage.XLIST_LITERAL:
				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()) {
					sequence_XAnnotationElementValueOrCommaList_XListLiteral(context, (XListLiteral) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getXAnnotationElementValueRule()) {
					sequence_XAnnotationElementValue_XListLiteral(context, (XListLiteral) semanticObject); 
					return; 
				}
				else if (action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
						|| rule == grammarAccess.getXExpressionRule()
						|| rule == grammarAccess.getXAssignmentRule()
						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOrExpressionRule()
						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAndExpressionRule()
						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXEqualityExpressionRule()
						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXRelationalExpressionRule()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAdditiveExpressionRule()
						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXUnaryOperationRule()
						|| rule == grammarAccess.getXCastedExpressionRule()
						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
						|| rule == grammarAccess.getXPostfixOperationRule()
						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
						|| rule == grammarAccess.getXMemberFeatureCallRule()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
						|| rule == grammarAccess.getXPrimaryExpressionRule()
						|| rule == grammarAccess.getXLiteralRule()
						|| rule == grammarAccess.getXCollectionLiteralRule()
						|| rule == grammarAccess.getXListLiteralRule()
						|| rule == grammarAccess.getXParenthesizedExpressionRule()
						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
					sequence_XListLiteral(context, (XListLiteral) semanticObject); 
					return; 
				}
				else break;
			case XbasePackage.XMEMBER_FEATURE_CALL:
				sequence_XMemberFeatureCall(context, (XMemberFeatureCall) semanticObject); 
				return; 
			case XbasePackage.XNULL_LITERAL:
				sequence_XNullLiteral(context, (XNullLiteral) semanticObject); 
				return; 
			case XbasePackage.XNUMBER_LITERAL:
				sequence_XNumberLiteral(context, (XNumberLiteral) semanticObject); 
				return; 
			case XbasePackage.XPOSTFIX_OPERATION:
				sequence_XPostfixOperation(context, (XPostfixOperation) semanticObject); 
				return; 
			case XbasePackage.XRETURN_EXPRESSION:
				sequence_XReturnExpression(context, (XReturnExpression) semanticObject); 
				return; 
			case XbasePackage.XSET_LITERAL:
				sequence_XSetLiteral(context, (XSetLiteral) semanticObject); 
				return; 
			case XbasePackage.XSTRING_LITERAL:
				sequence_XStringLiteral(context, (XStringLiteral) semanticObject); 
				return; 
			case XbasePackage.XSWITCH_EXPRESSION:
				sequence_XSwitchExpression(context, (XSwitchExpression) semanticObject); 
				return; 
			case XbasePackage.XSYNCHRONIZED_EXPRESSION:
				sequence_XSynchronizedExpression(context, (XSynchronizedExpression) semanticObject); 
				return; 
			case XbasePackage.XTHROW_EXPRESSION:
				sequence_XThrowExpression(context, (XThrowExpression) semanticObject); 
				return; 
			case XbasePackage.XTRY_CATCH_FINALLY_EXPRESSION:
				sequence_XTryCatchFinallyExpression(context, (XTryCatchFinallyExpression) semanticObject); 
				return; 
			case XbasePackage.XTYPE_LITERAL:
				sequence_XTypeLiteral(context, (XTypeLiteral) semanticObject); 
				return; 
			case XbasePackage.XUNARY_OPERATION:
				sequence_XUnaryOperation(context, (XUnaryOperation) semanticObject); 
				return; 
			case XbasePackage.XVARIABLE_DECLARATION:
				sequence_XVariableDeclaration(context, (XVariableDeclaration) semanticObject); 
				return; 
			case XbasePackage.XWHILE_EXPRESSION:
				sequence_XWhileExpression(context, (XWhileExpression) semanticObject); 
				return; 
			}
		else if (epackage == XtypePackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case XtypePackage.XFUNCTION_TYPE_REF:
				sequence_XFunctionTypeRef(context, (XFunctionTypeRef) semanticObject); 
				return; 
			case XtypePackage.XIMPORT_SECTION:
				sequence_XImportSection(context, (XImportSection) semanticObject); 
				return; 
			}
		if (errorAcceptor != null)
			errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionButtonCaption
	 *     FSMActionButtonCaption returns FSMActionButtonCaption
	 *
	 * Constraint:
	 *     (caption=FSMActionFieldConcatenation attribute=[FSMControlButtonAttribute|ID])
	 */
	protected void sequence_FSMActionButtonCaption(ISerializationContext context, FSMActionButtonCaption semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_CAPTION__CAPTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_CAPTION__CAPTION));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_CAPTION__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_CAPTION__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionButtonCaptionAccess().getCaptionFSMActionFieldConcatenationParserRuleCall_1_0(), semanticObject.getCaption());
		feeder.accept(grammarAccess.getFSMActionButtonCaptionAccess().getAttributeFSMControlButtonAttributeIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_CAPTION__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionButtonImage
	 *     FSMActionButtonImage returns FSMActionButtonImage
	 *
	 * Constraint:
	 *     (image=STRING attribute=[FSMControlButtonAttribute|ID])
	 */
	protected void sequence_FSMActionButtonImage(ISerializationContext context, FSMActionButtonImage semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_IMAGE__IMAGE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_IMAGE__IMAGE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_IMAGE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_IMAGE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionButtonImageAccess().getImageSTRINGTerminalRuleCall_1_0(), semanticObject.getImage());
		feeder.accept(grammarAccess.getFSMActionButtonImageAccess().getAttributeFSMControlButtonAttributeIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_BUTTON_IMAGE__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionConditionalTransition
	 *     FSMActionConditionalTransition returns FSMActionConditionalTransition
	 *
	 * Constraint:
	 *     (transition=[FSMState|ID] guard=FSMGuard actions+=FSMAction*)
	 */
	protected void sequence_FSMActionConditionalTransition(ISerializationContext context, FSMActionConditionalTransition semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionDTOClear
	 *     FSMActionDTOClear returns FSMActionDTOClear
	 *
	 * Constraint:
	 *     dto=[FSMControlDTOAttribute|ID]
	 */
	protected void sequence_FSMActionDTOClear(ISerializationContext context, FSMActionDTOClear semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_DTO_CLEAR__DTO) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_DTO_CLEAR__DTO));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionDTOClearAccess().getDtoFSMControlDTOAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_DTO_CLEAR__DTO, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionDTOFind
	 *     FSMActionDTOFind returns FSMActionDTOFind
	 *
	 * Constraint:
	 *     (search=FSMActionFieldConcatenation dto=[FSMControlDTOAttribute|ID] attribute=[LDtoInheritedAttribute|ID])
	 */
	protected void sequence_FSMActionDTOFind(ISerializationContext context, FSMActionDTOFind semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_DTO_FIND__SEARCH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_DTO_FIND__SEARCH));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_DTO_FIND__DTO) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_DTO_FIND__DTO));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_DTO_FIND__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_DTO_FIND__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionDTOFindAccess().getSearchFSMActionFieldConcatenationParserRuleCall_1_0(), semanticObject.getSearch());
		feeder.accept(grammarAccess.getFSMActionDTOFindAccess().getDtoFSMControlDTOAttributeIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_DTO_FIND__DTO, false));
		feeder.accept(grammarAccess.getFSMActionDTOFindAccess().getAttributeLDtoInheritedAttributeIDTerminalRuleCall_5_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_DTO_FIND__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionFieldClear
	 *     FSMActionFieldClear returns FSMActionFieldClear
	 *
	 * Constraint:
	 *     attribute=[FSMControlFieldAttribute|ID]
	 */
	protected void sequence_FSMActionFieldClear(ISerializationContext context, FSMActionFieldClear semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_CLEAR__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_CLEAR__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldClearAccess().getAttributeFSMControlFieldAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_CLEAR__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldConcatenation returns FSMActionFieldConcatenation
	 *
	 * Constraint:
	 *     (first=FSMActionFieldSource more+=FSMActionFieldSourceMore*)
	 */
	protected void sequence_FSMActionFieldConcatenation(ISerializationContext context, FSMActionFieldConcatenation semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionFieldFilterToggle
	 *     FSMActionFieldFilterToggle returns FSMActionFieldFilterToggle
	 *
	 * Constraint:
	 *     filter=[FSMControlFilter|ID]
	 */
	protected void sequence_FSMActionFieldFilterToggle(ISerializationContext context, FSMActionFieldFilterToggle semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_FILTER_TOGGLE__FILTER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_FILTER_TOGGLE__FILTER));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldFilterToggleAccess().getFilterFSMControlFilterIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_FILTER_TOGGLE__FILTER, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMActionFieldGet
	 *     FSMActionFieldGetMore returns FSMActionFieldGet
	 *
	 * Constraint:
	 *     attribute=[FSMControlFieldAttribute|ID]
	 */
	protected void sequence_FSMActionFieldGetMore(ISerializationContext context, FSMActionFieldGet semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_GET__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_GET__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldGetMoreAccess().getAttributeFSMControlFieldAttributeIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_GET__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldGet
	 *     FSMActionFieldGet returns FSMActionFieldGet
	 *
	 * Constraint:
	 *     attribute=[FSMControlFieldAttribute|ID]
	 */
	protected void sequence_FSMActionFieldGet(ISerializationContext context, FSMActionFieldGet semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_GET__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_GET__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldGetAccess().getAttributeFSMControlFieldAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_GET__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionFieldRemove
	 *     FSMActionFieldRemove returns FSMActionFieldRemove
	 *
	 * Constraint:
	 *     attribute=[FSMControlFieldAttribute|ID]
	 */
	protected void sequence_FSMActionFieldRemove(ISerializationContext context, FSMActionFieldRemove semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_REMOVE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_REMOVE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldRemoveAccess().getAttributeFSMControlFieldAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_REMOVE__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionFieldSet
	 *     FSMActionFieldSet returns FSMActionFieldSet
	 *
	 * Constraint:
	 *     (source=FSMActionFieldConcatenation attribute=[FSMControlFieldAttribute|ID])
	 */
	protected void sequence_FSMActionFieldSet(ISerializationContext context, FSMActionFieldSet semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SET__SOURCE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SET__SOURCE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SET__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SET__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSetAccess().getSourceFSMActionFieldConcatenationParserRuleCall_1_0(), semanticObject.getSource());
		feeder.accept(grammarAccess.getFSMActionFieldSetAccess().getAttributeFSMControlFieldAttributeIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SET__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMActionFieldSourceBoolean
	 *     FSMActionFieldSourceBooleanMore returns FSMActionFieldSourceBoolean
	 *
	 * Constraint:
	 *     value=BOOLEAN
	 */
	protected void sequence_FSMActionFieldSourceBooleanMore(ISerializationContext context, FSMActionFieldSourceBoolean semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_BOOLEAN__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_BOOLEAN__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceBooleanMoreAccess().getValueBOOLEANParserRuleCall_2_0(), semanticObject.isValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldSourceBoolean
	 *     FSMActionFieldSourceBoolean returns FSMActionFieldSourceBoolean
	 *
	 * Constraint:
	 *     value=BOOLEAN
	 */
	protected void sequence_FSMActionFieldSourceBoolean(ISerializationContext context, FSMActionFieldSourceBoolean semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_BOOLEAN__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_BOOLEAN__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceBooleanAccess().getValueBOOLEANParserRuleCall_0(), semanticObject.isValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMActionFieldSourceDtoAttribute
	 *     FSMActionFieldSourceDtoAttributeMore returns FSMActionFieldSourceDtoAttribute
	 *
	 * Constraint:
	 *     (dto=[FSMControlDTOAttribute|ID] attribute=[LDtoInheritedAttribute|ID])
	 */
	protected void sequence_FSMActionFieldSourceDtoAttributeMore(ISerializationContext context, FSMActionFieldSourceDtoAttribute semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__DTO) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__DTO));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceDtoAttributeMoreAccess().getDtoFSMControlDTOAttributeIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__DTO, false));
		feeder.accept(grammarAccess.getFSMActionFieldSourceDtoAttributeMoreAccess().getAttributeLDtoInheritedAttributeIDTerminalRuleCall_5_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldSourceDtoAttribute
	 *     FSMActionFieldSourceDtoAttribute returns FSMActionFieldSourceDtoAttribute
	 *
	 * Constraint:
	 *     (dto=[FSMControlDTOAttribute|ID] attribute=[LDtoInheritedAttribute|ID])
	 */
	protected void sequence_FSMActionFieldSourceDtoAttribute(ISerializationContext context, FSMActionFieldSourceDtoAttribute semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__DTO) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__DTO));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceDtoAttributeAccess().getDtoFSMControlDTOAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__DTO, false));
		feeder.accept(grammarAccess.getFSMActionFieldSourceDtoAttributeAccess().getAttributeLDtoInheritedAttributeIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_DTO_ATTRIBUTE__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMActionFieldSourceEvaluate
	 *     FSMActionFieldSourceEvaluateMore returns FSMActionFieldSourceEvaluate
	 *
	 * Constraint:
	 *     evaluationtype=FSMEvaluationType
	 */
	protected void sequence_FSMActionFieldSourceEvaluateMore(ISerializationContext context, FSMActionFieldSourceEvaluate semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_EVALUATE__EVALUATIONTYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_EVALUATE__EVALUATIONTYPE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceEvaluateMoreAccess().getEvaluationtypeFSMEvaluationTypeEnumRuleCall_2_0(), semanticObject.getEvaluationtype());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldSourceEvaluate
	 *     FSMActionFieldSourceEvaluate returns FSMActionFieldSourceEvaluate
	 *
	 * Constraint:
	 *     evaluationtype=FSMEvaluationType
	 */
	protected void sequence_FSMActionFieldSourceEvaluate(ISerializationContext context, FSMActionFieldSourceEvaluate semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_EVALUATE__EVALUATIONTYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_EVALUATE__EVALUATIONTYPE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceEvaluateAccess().getEvaluationtypeFSMEvaluationTypeEnumRuleCall_0(), semanticObject.getEvaluationtype());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldSourceEvent
	 *     FSMActionFieldSourceEvent returns FSMActionFieldSourceEvent
	 *
	 * Constraint:
	 *     {FSMActionFieldSourceEvent}
	 */
	protected void sequence_FSMActionFieldSourceEvent(ISerializationContext context, FSMActionFieldSourceEvent semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMActionFieldSourceInteger
	 *     FSMActionFieldSourceIntegerMore returns FSMActionFieldSourceInteger
	 *
	 * Constraint:
	 *     value=INTEGER
	 */
	protected void sequence_FSMActionFieldSourceIntegerMore(ISerializationContext context, FSMActionFieldSourceInteger semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_INTEGER__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_INTEGER__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceIntegerMoreAccess().getValueINTEGERParserRuleCall_2_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldSourceInteger
	 *     FSMActionFieldSourceInteger returns FSMActionFieldSourceInteger
	 *
	 * Constraint:
	 *     value=INTEGER
	 */
	protected void sequence_FSMActionFieldSourceInteger(ISerializationContext context, FSMActionFieldSourceInteger semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_INTEGER__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_INTEGER__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceIntegerAccess().getValueINTEGERParserRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMActionFieldSourceNumber
	 *     FSMActionFieldSourceNumberMore returns FSMActionFieldSourceNumber
	 *
	 * Constraint:
	 *     value=SignedNumber
	 */
	protected void sequence_FSMActionFieldSourceNumberMore(ISerializationContext context, FSMActionFieldSourceNumber semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_NUMBER__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_NUMBER__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceNumberMoreAccess().getValueSignedNumberParserRuleCall_2_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldSourceNumber
	 *     FSMActionFieldSourceNumber returns FSMActionFieldSourceNumber
	 *
	 * Constraint:
	 *     value=SignedNumber
	 */
	protected void sequence_FSMActionFieldSourceNumber(ISerializationContext context, FSMActionFieldSourceNumber semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_NUMBER__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_NUMBER__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceNumberAccess().getValueSignedNumberParserRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMActionFieldSourceString
	 *     FSMActionFieldSourceStringMore returns FSMActionFieldSourceString
	 *
	 * Constraint:
	 *     text=STRING
	 */
	protected void sequence_FSMActionFieldSourceStringMore(ISerializationContext context, FSMActionFieldSourceString semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_STRING__TEXT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_STRING__TEXT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceStringMoreAccess().getTextSTRINGTerminalRuleCall_2_0(), semanticObject.getText());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldSourceString
	 *     FSMActionFieldSourceString returns FSMActionFieldSourceString
	 *
	 * Constraint:
	 *     text=STRING
	 */
	protected void sequence_FSMActionFieldSourceString(ISerializationContext context, FSMActionFieldSourceString semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_STRING__TEXT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_STRING__TEXT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceStringAccess().getTextSTRINGTerminalRuleCall_0(), semanticObject.getText());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMActionFieldSourceTranslate
	 *     FSMActionFieldSourceTranslateMore returns FSMActionFieldSourceTranslate
	 *
	 * Constraint:
	 *     text=TRANSLATABLESTRING
	 */
	protected void sequence_FSMActionFieldSourceTranslateMore(ISerializationContext context, FSMActionFieldSourceTranslate semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_TRANSLATE__TEXT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_TRANSLATE__TEXT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceTranslateMoreAccess().getTextTRANSLATABLESTRINGParserRuleCall_3_0(), semanticObject.getText());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMActionFieldSourceTranslate
	 *     FSMActionFieldSourceTranslate returns FSMActionFieldSourceTranslate
	 *
	 * Constraint:
	 *     text=TRANSLATABLESTRING
	 */
	protected void sequence_FSMActionFieldSourceTranslate(ISerializationContext context, FSMActionFieldSourceTranslate semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_TRANSLATE__TEXT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_FIELD_SOURCE_TRANSLATE__TEXT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionFieldSourceTranslateAccess().getTextTRANSLATABLESTRINGParserRuleCall_1_0(), semanticObject.getText());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionItemInvisible
	 *     FSMActionItemInvisible returns FSMActionItemInvisible
	 *
	 * Constraint:
	 *     attribute=[FSMControlVisibility|ID]
	 */
	protected void sequence_FSMActionItemInvisible(ISerializationContext context, FSMActionItemInvisible semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_ITEM_INVISIBLE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_ITEM_INVISIBLE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionItemInvisibleAccess().getAttributeFSMControlVisibilityIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_ITEM_INVISIBLE__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionItemVisible
	 *     FSMActionItemVisible returns FSMActionItemVisible
	 *
	 * Constraint:
	 *     attribute=[FSMControlVisibility|ID]
	 */
	protected void sequence_FSMActionItemVisible(ISerializationContext context, FSMActionItemVisible semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_ITEM_VISIBLE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_ITEM_VISIBLE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionItemVisibleAccess().getAttributeFSMControlVisibilityIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_ITEM_VISIBLE__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralBeeper
	 *     FSMActionPeripheralBeeper returns FSMActionPeripheralBeeper
	 *
	 * Constraint:
	 *     (duration=INT frequency=INT)
	 */
	protected void sequence_FSMActionPeripheralBeeper(ISerializationContext context, FSMActionPeripheralBeeper semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BEEPER__DURATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BEEPER__DURATION));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BEEPER__FREQUENCY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BEEPER__FREQUENCY));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralBeeperAccess().getDurationINTTerminalRuleCall_2_0(), semanticObject.getDuration());
		feeder.accept(grammarAccess.getFSMActionPeripheralBeeperAccess().getFrequencyINTTerminalRuleCall_4_0(), semanticObject.getFrequency());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralBlinkRate
	 *     FSMActionPeripheralBlinkRate returns FSMActionPeripheralBlinkRate
	 *
	 * Constraint:
	 *     (blinkRate=INT device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralBlinkRate(ISerializationContext context, FSMActionPeripheralBlinkRate semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BLINK_RATE__BLINK_RATE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BLINK_RATE__BLINK_RATE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BLINK_RATE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BLINK_RATE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralBlinkRateAccess().getBlinkRateINTTerminalRuleCall_1_0(), semanticObject.getBlinkRate());
		feeder.accept(grammarAccess.getFSMActionPeripheralBlinkRateAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_BLINK_RATE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralClear
	 *     FSMActionPeripheralClear returns FSMActionPeripheralClear
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceLineDisplay|ID]
	 */
	protected void sequence_FSMActionPeripheralClear(ISerializationContext context, FSMActionPeripheralClear semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CLEAR__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CLEAR__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralClearAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CLEAR__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralCreateWindow
	 *     FSMActionPeripheralCreateWindow returns FSMActionPeripheralCreateWindow
	 *
	 * Constraint:
	 *     (
	 *         viewportRow=INT 
	 *         viewportColumn=INT 
	 *         viewportHeight=INT 
	 *         viewportWidth=INT 
	 *         windowHeight=INT 
	 *         windowWidth=INT 
	 *         device=[FSMPeripheralDeviceLineDisplay|ID]
	 *     )
	 */
	protected void sequence_FSMActionPeripheralCreateWindow(ISerializationContext context, FSMActionPeripheralCreateWindow semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__VIEWPORT_ROW) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__VIEWPORT_ROW));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__VIEWPORT_COLUMN) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__VIEWPORT_COLUMN));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__VIEWPORT_HEIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__VIEWPORT_HEIGHT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__VIEWPORT_WIDTH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__VIEWPORT_WIDTH));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__WINDOW_HEIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__WINDOW_HEIGHT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__WINDOW_WIDTH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__WINDOW_WIDTH));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralCreateWindowAccess().getViewportRowINTTerminalRuleCall_2_0(), semanticObject.getViewportRow());
		feeder.accept(grammarAccess.getFSMActionPeripheralCreateWindowAccess().getViewportColumnINTTerminalRuleCall_4_0(), semanticObject.getViewportColumn());
		feeder.accept(grammarAccess.getFSMActionPeripheralCreateWindowAccess().getViewportHeightINTTerminalRuleCall_6_0(), semanticObject.getViewportHeight());
		feeder.accept(grammarAccess.getFSMActionPeripheralCreateWindowAccess().getViewportWidthINTTerminalRuleCall_8_0(), semanticObject.getViewportWidth());
		feeder.accept(grammarAccess.getFSMActionPeripheralCreateWindowAccess().getWindowHeightINTTerminalRuleCall_10_0(), semanticObject.getWindowHeight());
		feeder.accept(grammarAccess.getFSMActionPeripheralCreateWindowAccess().getWindowWidthINTTerminalRuleCall_12_0(), semanticObject.getWindowWidth());
		feeder.accept(grammarAccess.getFSMActionPeripheralCreateWindowAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_14_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CREATE_WINDOW__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralCursorType
	 *     FSMActionPeripheralCursorType returns FSMActionPeripheralCursorType
	 *
	 * Constraint:
	 *     (cursorType=FSMLineDisplayCursorType device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralCursorType(ISerializationContext context, FSMActionPeripheralCursorType semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CURSOR_TYPE__CURSOR_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CURSOR_TYPE__CURSOR_TYPE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CURSOR_TYPE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CURSOR_TYPE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralCursorTypeAccess().getCursorTypeFSMLineDisplayCursorTypeEnumRuleCall_1_0(), semanticObject.getCursorType());
		feeder.accept(grammarAccess.getFSMActionPeripheralCursorTypeAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_CURSOR_TYPE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralDestroyWindow
	 *     FSMActionPeripheralDestroyWindow returns FSMActionPeripheralDestroyWindow
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceLineDisplay|ID]
	 */
	protected void sequence_FSMActionPeripheralDestroyWindow(ISerializationContext context, FSMActionPeripheralDestroyWindow semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DESTROY_WINDOW__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DESTROY_WINDOW__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralDestroyWindowAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DESTROY_WINDOW__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralDeviceBrightness
	 *     FSMActionPeripheralDeviceBrightness returns FSMActionPeripheralDeviceBrightness
	 *
	 * Constraint:
	 *     (brightness=INT device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralDeviceBrightness(ISerializationContext context, FSMActionPeripheralDeviceBrightness semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DEVICE_BRIGHTNESS__BRIGHTNESS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DEVICE_BRIGHTNESS__BRIGHTNESS));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DEVICE_BRIGHTNESS__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DEVICE_BRIGHTNESS__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralDeviceBrightnessAccess().getBrightnessINTTerminalRuleCall_1_0(), semanticObject.getBrightness());
		feeder.accept(grammarAccess.getFSMActionPeripheralDeviceBrightnessAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DEVICE_BRIGHTNESS__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralDisplayText
	 *     FSMActionPeripheralDisplayText returns FSMActionPeripheralDisplayText
	 *
	 * Constraint:
	 *     (text=FSMActionFieldConcatenation device=[FSMPeripheralDeviceDisplay|ID] attribute=[LDtoAttribute|ID])
	 */
	protected void sequence_FSMActionPeripheralDisplayText(ISerializationContext context, FSMActionPeripheralDisplayText semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT__TEXT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT__TEXT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT__DEVICE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralDisplayTextAccess().getTextFSMActionFieldConcatenationParserRuleCall_1_0(), semanticObject.getText());
		feeder.accept(grammarAccess.getFSMActionPeripheralDisplayTextAccess().getDeviceFSMPeripheralDeviceDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT__DEVICE, false));
		feeder.accept(grammarAccess.getFSMActionPeripheralDisplayTextAccess().getAttributeLDtoAttributeIDTerminalRuleCall_5_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_DISPLAY_TEXT__ATTRIBUTE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralInterCharacterWait
	 *     FSMActionPeripheralInterCharacterWait returns FSMActionPeripheralInterCharacterWait
	 *
	 * Constraint:
	 *     (wait=INT device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralInterCharacterWait(ISerializationContext context, FSMActionPeripheralInterCharacterWait semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_INTER_CHARACTER_WAIT__WAIT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_INTER_CHARACTER_WAIT__WAIT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_INTER_CHARACTER_WAIT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_INTER_CHARACTER_WAIT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralInterCharacterWaitAccess().getWaitINTTerminalRuleCall_1_0(), semanticObject.getWait());
		feeder.accept(grammarAccess.getFSMActionPeripheralInterCharacterWaitAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_INTER_CHARACTER_WAIT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralLineDisplayTextAt
	 *     FSMActionPeripheralLineDisplayTextAt returns FSMActionPeripheralLineDisplayTextAt
	 *
	 * Constraint:
	 *     (
	 *         text=FSMActionFieldConcatenation 
	 *         row=INT 
	 *         column=INT 
	 *         (hasType?='type' textType=FSMLineDisplayTextType)? 
	 *         device=[FSMPeripheralDeviceLineDisplay|ID]
	 *     )
	 */
	protected void sequence_FSMActionPeripheralLineDisplayTextAt(ISerializationContext context, FSMActionPeripheralLineDisplayTextAt semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralLineDisplayText
	 *     FSMActionPeripheralLineDisplayText returns FSMActionPeripheralLineDisplayText
	 *
	 * Constraint:
	 *     (text=FSMActionFieldConcatenation (hasType?='type' textType=FSMLineDisplayTextType)? device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralLineDisplayText(ISerializationContext context, FSMActionPeripheralLineDisplayText semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralMarqueeFormat
	 *     FSMActionPeripheralMarqueeFormat returns FSMActionPeripheralMarqueeFormat
	 *
	 * Constraint:
	 *     (format=FSMLineDisplayMarqueeFormat device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralMarqueeFormat(ISerializationContext context, FSMActionPeripheralMarqueeFormat semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_FORMAT__FORMAT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_FORMAT__FORMAT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_FORMAT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_FORMAT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralMarqueeFormatAccess().getFormatFSMLineDisplayMarqueeFormatEnumRuleCall_1_0(), semanticObject.getFormat());
		feeder.accept(grammarAccess.getFSMActionPeripheralMarqueeFormatAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_FORMAT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralMarqueeRepeatWait
	 *     FSMActionPeripheralMarqueeRepeatWait returns FSMActionPeripheralMarqueeRepeatWait
	 *
	 * Constraint:
	 *     (wait=INT device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralMarqueeRepeatWait(ISerializationContext context, FSMActionPeripheralMarqueeRepeatWait semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_REPEAT_WAIT__WAIT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_REPEAT_WAIT__WAIT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_REPEAT_WAIT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_REPEAT_WAIT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralMarqueeRepeatWaitAccess().getWaitINTTerminalRuleCall_1_0(), semanticObject.getWait());
		feeder.accept(grammarAccess.getFSMActionPeripheralMarqueeRepeatWaitAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_REPEAT_WAIT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralMarqueeType
	 *     FSMActionPeripheralMarqueeType returns FSMActionPeripheralMarqueeType
	 *
	 * Constraint:
	 *     (marqueeType=FSMLineDisplayMarqueeType device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralMarqueeType(ISerializationContext context, FSMActionPeripheralMarqueeType semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_TYPE__MARQUEE_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_TYPE__MARQUEE_TYPE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_TYPE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_TYPE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralMarqueeTypeAccess().getMarqueeTypeFSMLineDisplayMarqueeTypeEnumRuleCall_1_0(), semanticObject.getMarqueeType());
		feeder.accept(grammarAccess.getFSMActionPeripheralMarqueeTypeAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_TYPE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralMarqueeUnitWait
	 *     FSMActionPeripheralMarqueeUnitWait returns FSMActionPeripheralMarqueeUnitWait
	 *
	 * Constraint:
	 *     (wait=INT device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralMarqueeUnitWait(ISerializationContext context, FSMActionPeripheralMarqueeUnitWait semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_UNIT_WAIT__WAIT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_UNIT_WAIT__WAIT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_UNIT_WAIT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_UNIT_WAIT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralMarqueeUnitWaitAccess().getWaitINTTerminalRuleCall_1_0(), semanticObject.getWait());
		feeder.accept(grammarAccess.getFSMActionPeripheralMarqueeUnitWaitAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_MARQUEE_UNIT_WAIT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralOpenDrawer
	 *     FSMActionPeripheralOpenDrawer returns FSMActionPeripheralOpenDrawer
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceCashDrawer|ID]
	 */
	protected void sequence_FSMActionPeripheralOpenDrawer(ISerializationContext context, FSMActionPeripheralOpenDrawer semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_OPEN_DRAWER__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_OPEN_DRAWER__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralOpenDrawerAccess().getDeviceFSMPeripheralDeviceCashDrawerIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_OPEN_DRAWER__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPTAcknowledge
	 *     FSMActionPeripheralPTAcknowledge returns FSMActionPeripheralPTAcknowledge
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDevicePT|ID]
	 */
	protected void sequence_FSMActionPeripheralPTAcknowledge(ISerializationContext context, FSMActionPeripheralPTAcknowledge semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_ACKNOWLEDGE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_ACKNOWLEDGE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPTAcknowledgeAccess().getDeviceFSMPeripheralDevicePTIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_ACKNOWLEDGE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPTAuthorization
	 *     FSMActionPeripheralPTAuthorization returns FSMActionPeripheralPTAuthorization
	 *
	 * Constraint:
	 *     (amount=FSMActionFieldConcatenation device=[FSMPeripheralDevicePT|ID])
	 */
	protected void sequence_FSMActionPeripheralPTAuthorization(ISerializationContext context, FSMActionPeripheralPTAuthorization semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_AUTHORIZATION__AMOUNT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_AUTHORIZATION__AMOUNT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_AUTHORIZATION__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_AUTHORIZATION__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPTAuthorizationAccess().getAmountFSMActionFieldConcatenationParserRuleCall_2_0(), semanticObject.getAmount());
		feeder.accept(grammarAccess.getFSMActionPeripheralPTAuthorizationAccess().getDeviceFSMPeripheralDevicePTIDTerminalRuleCall_4_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_AUTHORIZATION__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPTClose
	 *     FSMActionPeripheralPTClose returns FSMActionPeripheralPTClose
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDevicePT|ID]
	 */
	protected void sequence_FSMActionPeripheralPTClose(ISerializationContext context, FSMActionPeripheralPTClose semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_CLOSE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_CLOSE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPTCloseAccess().getDeviceFSMPeripheralDevicePTIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_CLOSE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPTOpen
	 *     FSMActionPeripheralPTOpen returns FSMActionPeripheralPTOpen
	 *
	 * Constraint:
	 *     (host=FSMActionFieldConcatenation port=FSMActionFieldConcatenation device=[FSMPeripheralDevicePT|ID])
	 */
	protected void sequence_FSMActionPeripheralPTOpen(ISerializationContext context, FSMActionPeripheralPTOpen semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_OPEN__HOST) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_OPEN__HOST));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_OPEN__PORT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_OPEN__PORT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_OPEN__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_OPEN__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPTOpenAccess().getHostFSMActionFieldConcatenationParserRuleCall_2_0(), semanticObject.getHost());
		feeder.accept(grammarAccess.getFSMActionPeripheralPTOpenAccess().getPortFSMActionFieldConcatenationParserRuleCall_4_0(), semanticObject.getPort());
		feeder.accept(grammarAccess.getFSMActionPeripheralPTOpenAccess().getDeviceFSMPeripheralDevicePTIDTerminalRuleCall_6_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_OPEN__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPTRegistration
	 *     FSMActionPeripheralPTRegistration returns FSMActionPeripheralPTRegistration
	 *
	 * Constraint:
	 *     (password=FSMActionFieldConcatenation configuration=STRING device=[FSMPeripheralDevicePT|ID])
	 */
	protected void sequence_FSMActionPeripheralPTRegistration(ISerializationContext context, FSMActionPeripheralPTRegistration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REGISTRATION__PASSWORD) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REGISTRATION__PASSWORD));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REGISTRATION__CONFIGURATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REGISTRATION__CONFIGURATION));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REGISTRATION__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REGISTRATION__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPTRegistrationAccess().getPasswordFSMActionFieldConcatenationParserRuleCall_2_0(), semanticObject.getPassword());
		feeder.accept(grammarAccess.getFSMActionPeripheralPTRegistrationAccess().getConfigurationSTRINGTerminalRuleCall_4_0(), semanticObject.getConfiguration());
		feeder.accept(grammarAccess.getFSMActionPeripheralPTRegistrationAccess().getDeviceFSMPeripheralDevicePTIDTerminalRuleCall_6_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REGISTRATION__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionPeripheralPTResponse returns FSMActionPeripheralPTResponse
	 *     FSMActionFieldSource returns FSMActionPeripheralPTResponse
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDevicePT|ID]
	 */
	protected void sequence_FSMActionPeripheralPTResponse(ISerializationContext context, FSMActionPeripheralPTResponse semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_RESPONSE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_RESPONSE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPTResponseAccess().getDeviceFSMPeripheralDevicePTIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_RESPONSE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPTReversal
	 *     FSMActionPeripheralPTReversal returns FSMActionPeripheralPTReversal
	 *
	 * Constraint:
	 *     (password=FSMActionFieldConcatenation receipt=FSMActionFieldConcatenation device=[FSMPeripheralDevicePT|ID])
	 */
	protected void sequence_FSMActionPeripheralPTReversal(ISerializationContext context, FSMActionPeripheralPTReversal semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REVERSAL__PASSWORD) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REVERSAL__PASSWORD));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REVERSAL__RECEIPT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REVERSAL__RECEIPT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REVERSAL__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REVERSAL__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPTReversalAccess().getPasswordFSMActionFieldConcatenationParserRuleCall_2_0(), semanticObject.getPassword());
		feeder.accept(grammarAccess.getFSMActionPeripheralPTReversalAccess().getReceiptFSMActionFieldConcatenationParserRuleCall_4_0(), semanticObject.getReceipt());
		feeder.accept(grammarAccess.getFSMActionPeripheralPTReversalAccess().getDeviceFSMPeripheralDevicePTIDTerminalRuleCall_6_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PT_REVERSAL__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPlayer
	 *     FSMActionPeripheralPlayer returns FSMActionPeripheralPlayer
	 *
	 * Constraint:
	 *     tune=STRING
	 */
	protected void sequence_FSMActionPeripheralPlayer(ISerializationContext context, FSMActionPeripheralPlayer semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PLAYER__TUNE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PLAYER__TUNE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPlayerAccess().getTuneSTRINGTerminalRuleCall_2_0(), semanticObject.getTune());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPrintBarcode
	 *     FSMActionPeripheralPrintBarcode returns FSMActionPeripheralPrintBarcode
	 *
	 * Constraint:
	 *     (data=STRING barcodeType=FSMPOSPrinterBarcodeType device=[FSMPeripheralDevicePOSPrinter|ID])
	 */
	protected void sequence_FSMActionPeripheralPrintBarcode(ISerializationContext context, FSMActionPeripheralPrintBarcode semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BARCODE__DATA) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BARCODE__DATA));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BARCODE__BARCODE_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BARCODE__BARCODE_TYPE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BARCODE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BARCODE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintBarcodeAccess().getDataSTRINGTerminalRuleCall_2_0(), semanticObject.getData());
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintBarcodeAccess().getBarcodeTypeFSMPOSPrinterBarcodeTypeEnumRuleCall_4_0(), semanticObject.getBarcodeType());
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintBarcodeAccess().getDeviceFSMPeripheralDevicePOSPrinterIDTerminalRuleCall_6_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BARCODE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPrintBitmap
	 *     FSMActionPeripheralPrintBitmap returns FSMActionPeripheralPrintBitmap
	 *
	 * Constraint:
	 *     (bitmapId=INT device=[FSMPeripheralDevicePOSPrinter|ID])
	 */
	protected void sequence_FSMActionPeripheralPrintBitmap(ISerializationContext context, FSMActionPeripheralPrintBitmap semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BITMAP__BITMAP_ID) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BITMAP__BITMAP_ID));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BITMAP__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BITMAP__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintBitmapAccess().getBitmapIdINTTerminalRuleCall_2_0(), semanticObject.getBitmapId());
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintBitmapAccess().getDeviceFSMPeripheralDevicePOSPrinterIDTerminalRuleCall_4_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_BITMAP__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPrintCut
	 *     FSMActionPeripheralPrintCut returns FSMActionPeripheralPrintCut
	 *
	 * Constraint:
	 *     (text=FSMActionFieldConcatenation device=[FSMPeripheralDevicePOSPrinter|ID])
	 */
	protected void sequence_FSMActionPeripheralPrintCut(ISerializationContext context, FSMActionPeripheralPrintCut semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_CUT__TEXT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_CUT__TEXT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_CUT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_CUT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintCutAccess().getTextFSMActionFieldConcatenationParserRuleCall_2_0(), semanticObject.getText());
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintCutAccess().getDeviceFSMPeripheralDevicePOSPrinterIDTerminalRuleCall_4_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_CUT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPrintNormal
	 *     FSMActionPeripheralPrintNormal returns FSMActionPeripheralPrintNormal
	 *
	 * Constraint:
	 *     (text=FSMActionFieldConcatenation device=[FSMPeripheralDevicePOSPrinter|ID])
	 */
	protected void sequence_FSMActionPeripheralPrintNormal(ISerializationContext context, FSMActionPeripheralPrintNormal semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_NORMAL__TEXT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_NORMAL__TEXT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_NORMAL__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_NORMAL__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintNormalAccess().getTextFSMActionFieldConcatenationParserRuleCall_2_0(), semanticObject.getText());
		feeder.accept(grammarAccess.getFSMActionPeripheralPrintNormalAccess().getDeviceFSMPeripheralDevicePOSPrinterIDTerminalRuleCall_4_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_PRINT_NORMAL__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralPrintReport
	 *     FSMActionPeripheralPrintReport returns FSMActionPeripheralPrintReport
	 *
	 * Constraint:
	 *     (report=[Report|ID] (hasFilter?='filterBy' key=[FSMStorage|ID])? (hasPrintService?='to' printService=FSMActionFieldConcatenation)?)
	 */
	protected void sequence_FSMActionPeripheralPrintReport(ISerializationContext context, FSMActionPeripheralPrintReport semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralScaleDisplayText
	 *     FSMActionPeripheralScaleDisplayText returns FSMActionPeripheralScaleDisplayText
	 *
	 * Constraint:
	 *     (text=FSMActionFieldConcatenation device=[FSMPeripheralDeviceScale|ID])
	 */
	protected void sequence_FSMActionPeripheralScaleDisplayText(ISerializationContext context, FSMActionPeripheralScaleDisplayText semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_DISPLAY_TEXT__TEXT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_DISPLAY_TEXT__TEXT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_DISPLAY_TEXT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_DISPLAY_TEXT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralScaleDisplayTextAccess().getTextFSMActionFieldConcatenationParserRuleCall_1_0(), semanticObject.getText());
		feeder.accept(grammarAccess.getFSMActionPeripheralScaleDisplayTextAccess().getDeviceFSMPeripheralDeviceScaleIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_DISPLAY_TEXT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionPeripheralScaleReadTareWeight returns FSMActionPeripheralScaleReadTareWeight
	 *     FSMActionFieldSource returns FSMActionPeripheralScaleReadTareWeight
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceScale|ID]
	 */
	protected void sequence_FSMActionPeripheralScaleReadTareWeight(ISerializationContext context, FSMActionPeripheralScaleReadTareWeight semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_READ_TARE_WEIGHT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_READ_TARE_WEIGHT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralScaleReadTareWeightAccess().getDeviceFSMPeripheralDeviceScaleIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_READ_TARE_WEIGHT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionPeripheralScaleReadWeight returns FSMActionPeripheralScaleReadWeight
	 *     FSMActionFieldSource returns FSMActionPeripheralScaleReadWeight
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceScale|ID]
	 */
	protected void sequence_FSMActionPeripheralScaleReadWeight(ISerializationContext context, FSMActionPeripheralScaleReadWeight semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_READ_WEIGHT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_READ_WEIGHT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralScaleReadWeightAccess().getDeviceFSMPeripheralDeviceScaleIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_READ_WEIGHT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralScaleTareWeight
	 *     FSMActionPeripheralScaleTareWeight returns FSMActionPeripheralScaleTareWeight
	 *
	 * Constraint:
	 *     (value=FSMActionFieldConcatenation device=[FSMPeripheralDeviceScale|ID])
	 */
	protected void sequence_FSMActionPeripheralScaleTareWeight(ISerializationContext context, FSMActionPeripheralScaleTareWeight semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_TARE_WEIGHT__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_TARE_WEIGHT__VALUE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_TARE_WEIGHT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_TARE_WEIGHT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralScaleTareWeightAccess().getValueFSMActionFieldConcatenationParserRuleCall_1_0(), semanticObject.getValue());
		feeder.accept(grammarAccess.getFSMActionPeripheralScaleTareWeightAccess().getDeviceFSMPeripheralDeviceScaleIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_TARE_WEIGHT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionPeripheralScaleWeightUnit returns FSMActionPeripheralScaleWeightUnit
	 *     FSMActionFieldSource returns FSMActionPeripheralScaleWeightUnit
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceScale|ID]
	 */
	protected void sequence_FSMActionPeripheralScaleWeightUnit(ISerializationContext context, FSMActionPeripheralScaleWeightUnit semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_WEIGHT_UNIT__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_WEIGHT_UNIT__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralScaleWeightUnitAccess().getDeviceFSMPeripheralDeviceScaleIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_WEIGHT_UNIT__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralScaleZero
	 *     FSMActionPeripheralScaleZero returns FSMActionPeripheralScaleZero
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceScale|ID]
	 */
	protected void sequence_FSMActionPeripheralScaleZero(ISerializationContext context, FSMActionPeripheralScaleZero semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_ZERO__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_ZERO__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralScaleZeroAccess().getDeviceFSMPeripheralDeviceScaleIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCALE_ZERO__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralScroll
	 *     FSMActionPeripheralScroll returns FSMActionPeripheralScroll
	 *
	 * Constraint:
	 *     (direction=FSMLineDisplayScrollTextType units=INT device=[FSMPeripheralDeviceLineDisplay|ID])
	 */
	protected void sequence_FSMActionPeripheralScroll(ISerializationContext context, FSMActionPeripheralScroll semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCROLL__DIRECTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCROLL__DIRECTION));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCROLL__UNITS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCROLL__UNITS));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCROLL__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCROLL__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralScrollAccess().getDirectionFSMLineDisplayScrollTextTypeEnumRuleCall_1_0(), semanticObject.getDirection());
		feeder.accept(grammarAccess.getFSMActionPeripheralScrollAccess().getUnitsINTTerminalRuleCall_2_0(), semanticObject.getUnits());
		feeder.accept(grammarAccess.getFSMActionPeripheralScrollAccess().getDeviceFSMPeripheralDeviceLineDisplayIDTerminalRuleCall_4_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SCROLL__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralSignatureCapture
	 *     FSMActionPeripheralSignatureCapture returns FSMActionPeripheralSignatureCapture
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceSignature|ID]
	 */
	protected void sequence_FSMActionPeripheralSignatureCapture(ISerializationContext context, FSMActionPeripheralSignatureCapture semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CAPTURE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CAPTURE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureCaptureAccess().getDeviceFSMPeripheralDeviceSignatureIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CAPTURE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralSignatureClear
	 *     FSMActionPeripheralSignatureClear returns FSMActionPeripheralSignatureClear
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceSignature|ID]
	 */
	protected void sequence_FSMActionPeripheralSignatureClear(ISerializationContext context, FSMActionPeripheralSignatureClear semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CLEAR__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CLEAR__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureClearAccess().getDeviceFSMPeripheralDeviceSignatureIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CLEAR__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralSignatureClose
	 *     FSMActionPeripheralSignatureClose returns FSMActionPeripheralSignatureClose
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceSignature|ID]
	 */
	protected void sequence_FSMActionPeripheralSignatureClose(ISerializationContext context, FSMActionPeripheralSignatureClose semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CLOSE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CLOSE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureCloseAccess().getDeviceFSMPeripheralDeviceSignatureIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_CLOSE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralSignatureIdle
	 *     FSMActionPeripheralSignatureIdle returns FSMActionPeripheralSignatureIdle
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceSignature|ID]
	 */
	protected void sequence_FSMActionPeripheralSignatureIdle(ISerializationContext context, FSMActionPeripheralSignatureIdle semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_IDLE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_IDLE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureIdleAccess().getDeviceFSMPeripheralDeviceSignatureIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_IDLE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralSignatureLabel
	 *     FSMActionPeripheralSignatureLabel returns FSMActionPeripheralSignatureLabel
	 *
	 * Constraint:
	 *     (okLabel=TRANSLATABLESTRING clearLabel=TRANSLATABLESTRING cancelLabel=TRANSLATABLESTRING device=[FSMPeripheralDeviceSignature|ID])
	 */
	protected void sequence_FSMActionPeripheralSignatureLabel(ISerializationContext context, FSMActionPeripheralSignatureLabel semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__OK_LABEL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__OK_LABEL));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__CLEAR_LABEL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__CLEAR_LABEL));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__CANCEL_LABEL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__CANCEL_LABEL));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureLabelAccess().getOkLabelTRANSLATABLESTRINGParserRuleCall_2_0(), semanticObject.getOkLabel());
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureLabelAccess().getClearLabelTRANSLATABLESTRINGParserRuleCall_4_0(), semanticObject.getClearLabel());
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureLabelAccess().getCancelLabelTRANSLATABLESTRINGParserRuleCall_6_0(), semanticObject.getCancelLabel());
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureLabelAccess().getDeviceFSMPeripheralDeviceSignatureIDTerminalRuleCall_8_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_LABEL__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralSignatureOpen
	 *     FSMActionPeripheralSignatureOpen returns FSMActionPeripheralSignatureOpen
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceSignature|ID]
	 */
	protected void sequence_FSMActionPeripheralSignatureOpen(ISerializationContext context, FSMActionPeripheralSignatureOpen semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_OPEN__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_OPEN__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralSignatureOpenAccess().getDeviceFSMPeripheralDeviceSignatureIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SIGNATURE_OPEN__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionPeripheralSound
	 *     FSMActionPeripheralSound returns FSMActionPeripheralSound
	 *
	 * Constraint:
	 *     name=STRING
	 */
	protected void sequence_FSMActionPeripheralSound(ISerializationContext context, FSMActionPeripheralSound semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SOUND__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_PERIPHERAL_SOUND__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionPeripheralSoundAccess().getNameSTRINGTerminalRuleCall_2_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMActionScheduler
	 *     FSMActionScheduler returns FSMActionScheduler
	 *
	 * Constraint:
	 *     scheduler=[FSMControlSchedulerAttribute|ID]
	 */
	protected void sequence_FSMActionScheduler(ISerializationContext context, FSMActionScheduler semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_SCHEDULER__SCHEDULER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_ACTION_SCHEDULER__SCHEDULER));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMActionSchedulerAccess().getSchedulerFSMControlSchedulerAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_ACTION_SCHEDULER__SCHEDULER, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAbstractFilter returns FSMAndFilter
	 *     FSMAndFilter returns FSMAndFilter
	 *
	 * Constraint:
	 *     (first=FSMFilter? more+=FSMFilterMore*)
	 */
	protected void sequence_FSMAndFilter(ISerializationContext context, FSMAndFilter semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAbstractFilter returns FSMBetweenFilter
	 *     FSMBetweenFilter returns FSMBetweenFilter
	 *
	 * Constraint:
	 *     (propertyId=FSMFilterProperty start=FSMActionFieldSource end=FSMActionFieldSource)
	 */
	protected void sequence_FSMBetweenFilter(ISerializationContext context, FSMBetweenFilter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BETWEEN_FILTER__PROPERTY_ID) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BETWEEN_FILTER__PROPERTY_ID));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BETWEEN_FILTER__START) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BETWEEN_FILTER__START));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BETWEEN_FILTER__END) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BETWEEN_FILTER__END));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMBetweenFilterAccess().getPropertyIdFSMFilterPropertyParserRuleCall_3_0(), semanticObject.getPropertyId());
		feeder.accept(grammarAccess.getFSMBetweenFilterAccess().getStartFSMActionFieldSourceParserRuleCall_5_0(), semanticObject.getStart());
		feeder.accept(grammarAccess.getFSMBetweenFilterAccess().getEndFSMActionFieldSourceParserRuleCall_7_0(), semanticObject.getEnd());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAbstractFilter returns FSMCompareFilter
	 *     FSMCompareFilter returns FSMCompareFilter
	 *
	 * Constraint:
	 *     (operation=FSMCompareOperationEnum propertyId=FSMFilterProperty operand=FSMActionFieldSource)
	 */
	protected void sequence_FSMCompareFilter(ISerializationContext context, FSMCompareFilter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_COMPARE_FILTER__OPERATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_COMPARE_FILTER__OPERATION));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_COMPARE_FILTER__PROPERTY_ID) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_COMPARE_FILTER__PROPERTY_ID));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_COMPARE_FILTER__OPERAND) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_COMPARE_FILTER__OPERAND));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMCompareFilterAccess().getOperationFSMCompareOperationEnumEnumRuleCall_1_0(), semanticObject.getOperation());
		feeder.accept(grammarAccess.getFSMCompareFilterAccess().getPropertyIdFSMFilterPropertyParserRuleCall_3_0(), semanticObject.getPropertyId());
		feeder.accept(grammarAccess.getFSMCompareFilterAccess().getOperandFSMActionFieldSourceParserRuleCall_5_0(), semanticObject.getOperand());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlButtonAttributeEvent returns FSMControlButtonAttributeEventEvent
	 *     FSMControlButtonAttributeEventEvent returns FSMControlButtonAttributeEventEvent
	 *
	 * Constraint:
	 *     event=[FSMEvent|ID]
	 */
	protected void sequence_FSMControlButtonAttributeEventEvent(ISerializationContext context, FSMControlButtonAttributeEventEvent semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_EVENT__EVENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_EVENT__EVENT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMControlButtonAttributeEventEventAccess().getEventFSMEventIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_EVENT__EVENT, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlButtonAttributeEvent returns FSMControlButtonAttributeEventIdentity
	 *     FSMControlButtonAttributeEventIdentity returns FSMControlButtonAttributeEventIdentity
	 *
	 * Constraint:
	 *     identity=INT
	 */
	protected void sequence_FSMControlButtonAttributeEventIdentity(ISerializationContext context, FSMControlButtonAttributeEventIdentity semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_IDENTITY__IDENTITY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_IDENTITY__IDENTITY));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMControlButtonAttributeEventIdentityAccess().getIdentityINTTerminalRuleCall_2_0(), semanticObject.getIdentity());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlButtonAttributeEvent returns FSMControlButtonAttributeEventKeyboard
	 *     FSMControlButtonAttributeEventKeyboard returns FSMControlButtonAttributeEventKeyboard
	 *
	 * Constraint:
	 *     keystroke=STRING
	 */
	protected void sequence_FSMControlButtonAttributeEventKeyboard(ISerializationContext context, FSMControlButtonAttributeEventKeyboard semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_KEYBOARD__KEYSTROKE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_BUTTON_ATTRIBUTE_EVENT_KEYBOARD__KEYSTROKE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMControlButtonAttributeEventKeyboardAccess().getKeystrokeSTRINGTerminalRuleCall_2_0(), semanticObject.getKeystroke());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlVisibility returns FSMControlButtonAttribute
	 *     FSMControlButtonAttribute returns FSMControlButtonAttribute
	 *
	 * Constraint:
	 *     (name=TRANSLATABLEID (hasImage?='image' image=STRING)? event=FSMControlButtonAttributeEvent)
	 */
	protected void sequence_FSMControlButtonAttribute(ISerializationContext context, FSMControlButtonAttribute semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlVisibility returns FSMControlButton
	 *     FSMControl returns FSMControlButton
	 *     FSMControlButton returns FSMControlButton
	 *
	 * Constraint:
	 *     (name=ID eventType=FSMControlButtonEventType (hasRange?='from' start=INT end=INT rangedName=STRING)? buttons+=FSMControlButtonAttribute*)
	 */
	protected void sequence_FSMControlButton(ISerializationContext context, FSMControlButton semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlDTOAttribute returns FSMControlDTOAttribute
	 *
	 * Constraint:
	 *     (name=ID attributeType=FSMDTOType ((hasEvent?='event' event=[FSMEvent|ID]) | (isAttached?='attach' display=[FSMPeripheralDeviceDisplay|ID]))*)
	 */
	protected void sequence_FSMControlDTOAttribute(ISerializationContext context, FSMControlDTOAttribute semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMControl returns FSMControlDTO
	 *     FSMControlDTO returns FSMControlDTO
	 *
	 * Constraint:
	 *     (name=ID (dtos+=FSMControlDTOAttribute | filters+=FSMControlFilter)*)
	 */
	protected void sequence_FSMControlDTO(ISerializationContext context, FSMControlDTO semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlVisibility returns FSMControlFieldAttribute
	 *     FSMControlFieldAttribute returns FSMControlFieldAttribute
	 *
	 * Constraint:
	 *     (name=TRANSLATABLEID attributeType=FSMFieldType)
	 */
	protected void sequence_FSMControlFieldAttribute(ISerializationContext context, FSMControlFieldAttribute semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_FIELD_ATTRIBUTE__ATTRIBUTE_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_FIELD_ATTRIBUTE__ATTRIBUTE_TYPE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMControlFieldAttributeAccess().getNameTRANSLATABLEIDParserRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getFSMControlFieldAttributeAccess().getAttributeTypeFSMFieldTypeParserRuleCall_3_0(), semanticObject.getAttributeType());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlVisibility returns FSMControlFieldLayout
	 *     FSMControlFieldLayout returns FSMControlFieldLayout
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_FSMControlFieldLayout(ISerializationContext context, FSMControlFieldLayout semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMControlFieldLayoutAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMControl returns FSMControlField
	 *     FSMControlField returns FSMControlField
	 *
	 * Constraint:
	 *     (name=ID (fields+=FSMControlFieldAttribute | layouts+=FSMControlFieldLayout)*)
	 */
	protected void sequence_FSMControlField(ISerializationContext context, FSMControlField semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlFilter returns FSMControlFilter
	 *
	 * Constraint:
	 *     (name=ID filter=FSMFilter)
	 */
	protected void sequence_FSMControlFilter(ISerializationContext context, FSMControlFilter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_FILTER__FILTER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_FILTER__FILTER));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMControlFilterAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getFSMControlFilterAccess().getFilterFSMFilterParserRuleCall_2_0(), semanticObject.getFilter());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMControl returns FSMControlPeripheral
	 *     FSMControlPeripheral returns FSMControlPeripheral
	 *
	 * Constraint:
	 *     (
	 *         name=ID 
	 *         (
	 *             lineDisplays+=FSMPeripheralDeviceLineDisplay | 
	 *             displays+=FSMPeripheralDeviceDisplay | 
	 *             posPrinters+=FSMPeripheralDevicePOSPrinter | 
	 *             cashDrawers+=FSMPeripheralDeviceCashDrawer | 
	 *             scales+=FSMPeripheralDeviceScale | 
	 *             paymentTerminals+=FSMPeripheralDevicePT | 
	 *             signaturePads+=FSMPeripheralDeviceSignature
	 *         )*
	 *     )
	 */
	protected void sequence_FSMControlPeripheral(ISerializationContext context, FSMControlPeripheral semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMControlSchedulerAttribute returns FSMControlSchedulerAttribute
	 *
	 * Constraint:
	 *     (name=ID delay=INT event=[FSMEvent|ID])
	 */
	protected void sequence_FSMControlSchedulerAttribute(ISerializationContext context, FSMControlSchedulerAttribute semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_SCHEDULER_ATTRIBUTE__DELAY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_SCHEDULER_ATTRIBUTE__DELAY));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_SCHEDULER_ATTRIBUTE__EVENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_CONTROL_SCHEDULER_ATTRIBUTE__EVENT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMControlSchedulerAttributeAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getFSMControlSchedulerAttributeAccess().getDelayINTTerminalRuleCall_3_0(), semanticObject.getDelay());
		feeder.accept(grammarAccess.getFSMControlSchedulerAttributeAccess().getEventFSMEventIDTerminalRuleCall_5_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_CONTROL_SCHEDULER_ATTRIBUTE__EVENT, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMControl returns FSMControlScheduler
	 *     FSMControlScheduler returns FSMControlScheduler
	 *
	 * Constraint:
	 *     (name=ID schedulers+=FSMControlSchedulerAttribute*)
	 */
	protected void sequence_FSMControlScheduler(ISerializationContext context, FSMControlScheduler semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMDTOType returns FSMDTOType
	 *
	 * Constraint:
	 *     attributeType=[LDto|ID]
	 */
	protected void sequence_FSMDTOType(ISerializationContext context, FSMDTOType semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSMDTO_TYPE__ATTRIBUTE_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSMDTO_TYPE__ATTRIBUTE_TYPE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMDTOTypeAccess().getAttributeTypeLDtoIDTerminalRuleCall_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSMDTO_TYPE__ATTRIBUTE_TYPE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMDotExpression returns FSMDotExpression
	 *     FSMDotExpression.FSMDotExpression_1_0 returns FSMDotExpression
	 *
	 * Constraint:
	 *     (ref=FSMDotExpression_FSMDotExpression_1_0 tail=[LFeature|ID])
	 */
	protected void sequence_FSMDotExpression(ISerializationContext context, FSMDotExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_DOT_EXPRESSION__REF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_DOT_EXPRESSION__REF));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_DOT_EXPRESSION__TAIL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_DOT_EXPRESSION__TAIL));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMDotExpressionAccess().getFSMDotExpressionRefAction_1_0(), semanticObject.getRef());
		feeder.accept(grammarAccess.getFSMDotExpressionAccess().getTailLFeatureIDTerminalRuleCall_1_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_DOT_EXPRESSION__TAIL, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMDotExpression returns FSMDtoRef
	 *     FSMDotExpression.FSMDotExpression_1_0 returns FSMDtoRef
	 *     FSMDtoRef returns FSMDtoRef
	 *
	 * Constraint:
	 *     dto=[FSMControlDTOAttribute|ID]
	 */
	protected void sequence_FSMDtoRef(ISerializationContext context, FSMDtoRef semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_DTO_REF__DTO) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_DTO_REF__DTO));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMDtoRefAccess().getDtoFSMControlDTOAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_DTO_REF__DTO, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMEvent returns FSMEvent
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_FSMEvent(ISerializationContext context, FSMEvent semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMEventAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMFieldType returns FSMFieldType
	 *
	 * Constraint:
	 *     attributeType=FSMInternalType
	 */
	protected void sequence_FSMFieldType(ISerializationContext context, FSMFieldType semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_FIELD_TYPE__ATTRIBUTE_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_FIELD_TYPE__ATTRIBUTE_TYPE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMFieldTypeAccess().getAttributeTypeFSMInternalTypeEnumRuleCall_0(), semanticObject.getAttributeType());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMFilterMore returns FSMFilter
	 *
	 * Constraint:
	 *     source=FSMAbstractFilter
	 */
	protected void sequence_FSMFilterMore(ISerializationContext context, FSMFilter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_FILTER__SOURCE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_FILTER__SOURCE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMFilterMoreAccess().getSourceFSMAbstractFilterParserRuleCall_2_0(), semanticObject.getSource());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMFilterProperty returns FSMFilterProperty
	 *
	 * Constraint:
	 *     path=FSMDotExpression
	 */
	protected void sequence_FSMFilterProperty(ISerializationContext context, FSMFilterProperty semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_FILTER_PROPERTY__PATH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_FILTER_PROPERTY__PATH));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMFilterPropertyAccess().getPathFSMDotExpressionParserRuleCall_1_0(), semanticObject.getPath());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMFilter returns FSMFilter
	 *
	 * Constraint:
	 *     source=FSMAbstractFilter
	 */
	protected void sequence_FSMFilter(ISerializationContext context, FSMFilter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_FILTER__SOURCE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_FILTER__SOURCE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMFilterAccess().getSourceFSMAbstractFilterParserRuleCall_1_0(), semanticObject.getSource());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMFunction
	 *     FSMFunction returns FSMFunction
	 *
	 * Constraint:
	 *     (group=[FunctionLibraryStatemachineGroup|ID] function=[FunctionLibraryFunction|ID] first=FSMOperationParameter? more+=FSMOperationParameterMore*)
	 */
	protected void sequence_FSMFunction(ISerializationContext context, FSMFunction semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMGuard returns FSMGuard
	 *
	 * Constraint:
	 *     (
	 *         group=[FunctionLibraryStatemachineGroup|ID] 
	 *         guard=[FunctionLibraryGuard|ID] 
	 *         (hasOnFail?='onFail' onFailCaption=TRANSLATABLESTRING onFailDescription=TRANSLATABLESTRING onFailType=FSMUserMessageType)?
	 *     )
	 */
	protected void sequence_FSMGuard(ISerializationContext context, FSMGuard semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAbstractFilter returns FSMIsNullFilter
	 *     FSMIsNullFilter returns FSMIsNullFilter
	 *
	 * Constraint:
	 *     propertyId=FSMFilterProperty
	 */
	protected void sequence_FSMIsNullFilter(ISerializationContext context, FSMIsNullFilter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_IS_NULL_FILTER__PROPERTY_ID) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_IS_NULL_FILTER__PROPERTY_ID));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMIsNullFilterAccess().getPropertyIdFSMFilterPropertyParserRuleCall_3_0(), semanticObject.getPropertyId());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMKeyMapper returns FSMKeyMapper
	 *
	 * Constraint:
	 *     (keyCode=FSMFunctionalKeyCodes keyEvent=[FSMEvent|ID])
	 */
	protected void sequence_FSMKeyMapper(ISerializationContext context, FSMKeyMapper semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_KEY_MAPPER__KEY_CODE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_KEY_MAPPER__KEY_CODE));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_KEY_MAPPER__KEY_EVENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_KEY_MAPPER__KEY_EVENT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMKeyMapperAccess().getKeyCodeFSMFunctionalKeyCodesEnumRuleCall_1_0(), semanticObject.getKeyCode());
		feeder.accept(grammarAccess.getFSMKeyMapperAccess().getKeyEventFSMEventIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_KEY_MAPPER__KEY_EVENT, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAbstractFilter returns FSMLikeFilter
	 *     FSMLikeFilter returns FSMLikeFilter
	 *
	 * Constraint:
	 *     (propertyId=FSMFilterProperty value=FSMActionFieldSource ignoreCase?='ignoreCase'?)
	 */
	protected void sequence_FSMLikeFilter(ISerializationContext context, FSMLikeFilter semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMModel returns FSMModel
	 *
	 * Constraint:
	 *     ((importSection=XImportSection packages+=FSMPackage+) | packages+=FSMPackage+)?
	 */
	protected void sequence_FSMModel(ISerializationContext context, FSMModel semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAbstractFilter returns FSMNotFilter
	 *     FSMNotFilter returns FSMNotFilter
	 *
	 * Constraint:
	 *     filter=FSMFilter
	 */
	protected void sequence_FSMNotFilter(ISerializationContext context, FSMNotFilter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_NOT_FILTER__FILTER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_NOT_FILTER__FILTER));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMNotFilterAccess().getFilterFSMFilterParserRuleCall_3_0(), semanticObject.getFilter());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMOperation
	 *     FSMOperationMore returns FSMOperation
	 *
	 * Constraint:
	 *     (group=[FunctionLibraryStatemachineGroup|ID] operation=[FunctionLibraryOperation|ID])
	 */
	protected void sequence_FSMOperationMore(ISerializationContext context, FSMOperation semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_OPERATION__GROUP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_OPERATION__GROUP));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_OPERATION__OPERATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_OPERATION__OPERATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMOperationMoreAccess().getGroupFunctionLibraryStatemachineGroupIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_OPERATION__GROUP, false));
		feeder.accept(grammarAccess.getFSMOperationMoreAccess().getOperationFunctionLibraryOperationIDTerminalRuleCall_5_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_OPERATION__OPERATION, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMOperationParameterMore returns FSMOperationParameter
	 *
	 * Constraint:
	 *     source=FSMActionFieldConcatenation
	 */
	protected void sequence_FSMOperationParameterMore(ISerializationContext context, FSMOperationParameter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_OPERATION_PARAMETER__SOURCE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_OPERATION_PARAMETER__SOURCE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMOperationParameterMoreAccess().getSourceFSMActionFieldConcatenationParserRuleCall_2_0(), semanticObject.getSource());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMOperationParameter returns FSMOperationParameter
	 *
	 * Constraint:
	 *     source=FSMActionFieldConcatenation
	 */
	protected void sequence_FSMOperationParameter(ISerializationContext context, FSMOperationParameter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_OPERATION_PARAMETER__SOURCE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_OPERATION_PARAMETER__SOURCE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMOperationParameterAccess().getSourceFSMActionFieldConcatenationParserRuleCall_0(), semanticObject.getSource());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMOperation
	 *     FSMOperation returns FSMOperation
	 *
	 * Constraint:
	 *     (
	 *         group=[FunctionLibraryStatemachineGroup|ID] 
	 *         operation=[FunctionLibraryOperation|ID] 
	 *         first=FSMOperationParameter? 
	 *         more+=FSMOperationParameterMore*
	 *     )
	 */
	protected void sequence_FSMOperation(ISerializationContext context, FSMOperation semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMAbstractFilter returns FSMOrFilter
	 *     FSMOrFilter returns FSMOrFilter
	 *
	 * Constraint:
	 *     (first=FSMFilter? more+=FSMFilterMore*)
	 */
	protected void sequence_FSMOrFilter(ISerializationContext context, FSMOrFilter semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMPackage returns FSMPackage
	 *
	 * Constraint:
	 *     (name=QualifiedName statemachines+=FSM*)
	 */
	protected void sequence_FSMPackage(ISerializationContext context, FSMPackage semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMPeripheralDeviceCashDrawer returns FSMPeripheralDeviceCashDrawer
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_FSMPeripheralDeviceCashDrawer(ISerializationContext context, FSMPeripheralDeviceCashDrawer semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMPeripheralDeviceCashDrawerAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMPeripheralDeviceDisplay returns FSMPeripheralDeviceDisplay
	 *
	 * Constraint:
	 *     (name=ID output=[FSMControlDTOAttribute|ID])
	 */
	protected void sequence_FSMPeripheralDeviceDisplay(ISerializationContext context, FSMPeripheralDeviceDisplay semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_PERIPHERAL_DEVICE_DISPLAY__OUTPUT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_PERIPHERAL_DEVICE_DISPLAY__OUTPUT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMPeripheralDeviceDisplayAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getFSMPeripheralDeviceDisplayAccess().getOutputFSMControlDTOAttributeIDTerminalRuleCall_3_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_PERIPHERAL_DEVICE_DISPLAY__OUTPUT, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMPeripheralDeviceLineDisplay returns FSMPeripheralDeviceLineDisplay
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_FSMPeripheralDeviceLineDisplay(ISerializationContext context, FSMPeripheralDeviceLineDisplay semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMPeripheralDeviceLineDisplayAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMPeripheralDevicePOSPrinter returns FSMPeripheralDevicePOSPrinter
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_FSMPeripheralDevicePOSPrinter(ISerializationContext context, FSMPeripheralDevicePOSPrinter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMPeripheralDevicePOSPrinterAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMPeripheralDevicePT returns FSMPeripheralDevicePT
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_FSMPeripheralDevicePT(ISerializationContext context, FSMPeripheralDevicePT semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMPeripheralDevicePTAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMPeripheralDeviceScale returns FSMPeripheralDeviceScale
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_FSMPeripheralDeviceScale(ISerializationContext context, FSMPeripheralDeviceScale semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMPeripheralDeviceScaleAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMPeripheralDeviceSignature returns FSMPeripheralDeviceSignature
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_FSMPeripheralDeviceSignature(ISerializationContext context, FSMPeripheralDeviceSignature semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_BASE__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMPeripheralDeviceSignatureAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMSignatureRetrieve returns FSMSignatureRetrieve
	 *     FSMActionFieldSource returns FSMSignatureRetrieve
	 *
	 * Constraint:
	 *     device=[FSMPeripheralDeviceSignature|ID]
	 */
	protected void sequence_FSMSignatureRetrieve(ISerializationContext context, FSMSignatureRetrieve semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_SIGNATURE_RETRIEVE__DEVICE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_SIGNATURE_RETRIEVE__DEVICE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMSignatureRetrieveAccess().getDeviceFSMPeripheralDeviceSignatureIDTerminalRuleCall_2_0_1(), semanticObject.eGet(StatemachineDSLPackage.Literals.FSM_SIGNATURE_RETRIEVE__DEVICE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMState returns FSMState
	 *
	 * Constraint:
	 *     (<unknown> name=ID)
	 */
	protected void sequence_FSMState(ISerializationContext context, FSMState semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSourceMore returns FSMStorageRetrieve
	 *     FSMStorageRetrieveMore returns FSMStorageRetrieve
	 *
	 * Constraint:
	 *     (key=ID attribute=ID)
	 */
	protected void sequence_FSMStorageRetrieveMore(ISerializationContext context, FSMStorageRetrieve semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE_RETRIEVE__KEY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE_RETRIEVE__KEY));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE_RETRIEVE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE_RETRIEVE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMStorageRetrieveMoreAccess().getKeyIDTerminalRuleCall_4_0(), semanticObject.getKey());
		feeder.accept(grammarAccess.getFSMStorageRetrieveMoreAccess().getAttributeIDTerminalRuleCall_6_0(), semanticObject.getAttribute());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMActionFieldSource returns FSMStorageRetrieve
	 *     FSMStorageRetrieve returns FSMStorageRetrieve
	 *
	 * Constraint:
	 *     (key=ID attribute=ID)
	 */
	protected void sequence_FSMStorageRetrieve(ISerializationContext context, FSMStorageRetrieve semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE_RETRIEVE__KEY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE_RETRIEVE__KEY));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE_RETRIEVE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE_RETRIEVE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMStorageRetrieveAccess().getKeyIDTerminalRuleCall_2_0(), semanticObject.getKey());
		feeder.accept(grammarAccess.getFSMStorageRetrieveAccess().getAttributeIDTerminalRuleCall_4_0(), semanticObject.getAttribute());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAction returns FSMStorage
	 *     FSMStorage returns FSMStorage
	 *
	 * Constraint:
	 *     (content=FSMActionFieldConcatenation key=ID attribute=ID)
	 */
	protected void sequence_FSMStorage(ISerializationContext context, FSMStorage semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE__CONTENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE__CONTENT));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE__KEY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE__KEY));
			if (transientValues.isValueTransient(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE__ATTRIBUTE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, StatemachineDSLPackage.Literals.FSM_STORAGE__ATTRIBUTE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFSMStorageAccess().getContentFSMActionFieldConcatenationParserRuleCall_1_0(), semanticObject.getContent());
		feeder.accept(grammarAccess.getFSMStorageAccess().getKeyIDTerminalRuleCall_3_0(), semanticObject.getKey());
		feeder.accept(grammarAccess.getFSMStorageAccess().getAttributeIDTerminalRuleCall_5_0(), semanticObject.getAttribute());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FSMAbstractFilter returns FSMStringFilter
	 *     FSMStringFilter returns FSMStringFilter
	 *
	 * Constraint:
	 *     (propertyId=FSMFilterProperty filterString=STRING ignoreCase?='ignoreCase'? onlyMatchPrefix?='onlyMatchPrefix'?)
	 */
	protected void sequence_FSMStringFilter(ISerializationContext context, FSMStringFilter semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSMTrigger returns FSMTrigger
	 *
	 * Constraint:
	 *     (triggers+=[FSMEvent|ID]* guards+=FSMGuard* (hasTransition?='transition' transition=[FSMState|ID])? actions+=FSMAction*)
	 */
	protected void sequence_FSMTrigger(ISerializationContext context, FSMTrigger semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     FSM returns FSM
	 *
	 * Constraint:
	 *     (
	 *         name=ID 
	 *         (description?='describedBy' descriptionValue=TRANSLATABLESTRING)? 
	 *         initialState=[FSMState|ID] 
	 *         initialEvent=[FSMEvent|ID] 
	 *         events+=FSMEvent* 
	 *         controls+=FSMControl* 
	 *         states+=FSMState*
	 *     )
	 */
	protected void sequence_FSM(ISerializationContext context, FSM semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
}