/*******************************************************************************
 * Copyright (c) 2015, 2016 CNRS, IRIT, IRT AESE (IRT Saint Exupéry).
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the LGPL 3.0
 * which accompanies this distribution, and is available at
 * https://www.gnu.org/licenses/lgpl-3.0-standalone.html
 *
 * Contributors:
 *      Faiez Zalila - initial API and implementation and/or initial documentation
 *******************************************************************************/
/*
 * generated by Xtext 2.10.0
 */
package fr.irit.fiacre.xtext.serializer;

import com.google.inject.Inject;
import fr.irit.fiacre.xtext.fiacre.AbsencePattern;
import fr.irit.fiacre.xtext.fiacre.Addition;
import fr.irit.fiacre.xtext.fiacre.AllExpression;
import fr.irit.fiacre.xtext.fiacre.AllProperty;
import fr.irit.fiacre.xtext.fiacre.AlwaysPattern;
import fr.irit.fiacre.xtext.fiacre.AnyPattern;
import fr.irit.fiacre.xtext.fiacre.AppendExpression;
import fr.irit.fiacre.xtext.fiacre.ArrayAccessExpression;
import fr.irit.fiacre.xtext.fiacre.ArrayAccessPattern;
import fr.irit.fiacre.xtext.fiacre.ArrayExpression;
import fr.irit.fiacre.xtext.fiacre.ArrayType;
import fr.irit.fiacre.xtext.fiacre.AssignAnyStatement;
import fr.irit.fiacre.xtext.fiacre.AssignStatement;
import fr.irit.fiacre.xtext.fiacre.BlockStatement;
import fr.irit.fiacre.xtext.fiacre.BooleanType;
import fr.irit.fiacre.xtext.fiacre.CaseStatement;
import fr.irit.fiacre.xtext.fiacre.ChannelDeclaration;
import fr.irit.fiacre.xtext.fiacre.ChannelType;
import fr.irit.fiacre.xtext.fiacre.ComparisonEqual;
import fr.irit.fiacre.xtext.fiacre.ComparisonGreater;
import fr.irit.fiacre.xtext.fiacre.ComparisonGreaterEqual;
import fr.irit.fiacre.xtext.fiacre.ComparisonLesser;
import fr.irit.fiacre.xtext.fiacre.ComparisonLesserEqual;
import fr.irit.fiacre.xtext.fiacre.ComparisonNotEqual;
import fr.irit.fiacre.xtext.fiacre.ComponentDeclaration;
import fr.irit.fiacre.xtext.fiacre.ComponentInstance;
import fr.irit.fiacre.xtext.fiacre.CompositeBlock;
import fr.irit.fiacre.xtext.fiacre.Composition;
import fr.irit.fiacre.xtext.fiacre.Conditional;
import fr.irit.fiacre.xtext.fiacre.ConditionalStatement;
import fr.irit.fiacre.xtext.fiacre.Conjunction;
import fr.irit.fiacre.xtext.fiacre.ConstantDeclaration;
import fr.irit.fiacre.xtext.fiacre.ConstantPattern;
import fr.irit.fiacre.xtext.fiacre.ConstructionExpression;
import fr.irit.fiacre.xtext.fiacre.ConstructorPattern;
import fr.irit.fiacre.xtext.fiacre.DeadlockFreePattern;
import fr.irit.fiacre.xtext.fiacre.DecimalLowerBound;
import fr.irit.fiacre.xtext.fiacre.DecimalUpperBound;
import fr.irit.fiacre.xtext.fiacre.Disjunction;
import fr.irit.fiacre.xtext.fiacre.Division;
import fr.irit.fiacre.xtext.fiacre.EnqueueExpression;
import fr.irit.fiacre.xtext.fiacre.EnterStateEvent;
import fr.irit.fiacre.xtext.fiacre.EventSubject;
import fr.irit.fiacre.xtext.fiacre.ExistsExpression;
import fr.irit.fiacre.xtext.fiacre.ExistsProperty;
import fr.irit.fiacre.xtext.fiacre.ExtendedConditionalStatement;
import fr.irit.fiacre.xtext.fiacre.FalseLiteral;
import fr.irit.fiacre.xtext.fiacre.FiacrePackage;
import fr.irit.fiacre.xtext.fiacre.FieldExpression;
import fr.irit.fiacre.xtext.fiacre.ForeachStatement;
import fr.irit.fiacre.xtext.fiacre.FunctionDeclaration;
import fr.irit.fiacre.xtext.fiacre.IdentifierExpression;
import fr.irit.fiacre.xtext.fiacre.IdentifierPattern;
import fr.irit.fiacre.xtext.fiacre.Implication;
import fr.irit.fiacre.xtext.fiacre.ImportDeclaration;
import fr.irit.fiacre.xtext.fiacre.InfiniteUpperBound;
import fr.irit.fiacre.xtext.fiacre.InfinitelyOftenPattern;
import fr.irit.fiacre.xtext.fiacre.InstanceDeclaration;
import fr.irit.fiacre.xtext.fiacre.IntegerPattern;
import fr.irit.fiacre.xtext.fiacre.IntegerType;
import fr.irit.fiacre.xtext.fiacre.LTLAll;
import fr.irit.fiacre.xtext.fiacre.LTLConjunction;
import fr.irit.fiacre.xtext.fiacre.LTLDisjunction;
import fr.irit.fiacre.xtext.fiacre.LTLExists;
import fr.irit.fiacre.xtext.fiacre.LTLImplication;
import fr.irit.fiacre.xtext.fiacre.LTLPattern;
import fr.irit.fiacre.xtext.fiacre.LTLRelease;
import fr.irit.fiacre.xtext.fiacre.LTLUnaryAlways;
import fr.irit.fiacre.xtext.fiacre.LTLUnaryEventually;
import fr.irit.fiacre.xtext.fiacre.LTLUnaryNegation;
import fr.irit.fiacre.xtext.fiacre.LTLUnaryNext;
import fr.irit.fiacre.xtext.fiacre.LTLUntil;
import fr.irit.fiacre.xtext.fiacre.LTLVariable;
import fr.irit.fiacre.xtext.fiacre.LeadsToPattern;
import fr.irit.fiacre.xtext.fiacre.LeaveStateEvent;
import fr.irit.fiacre.xtext.fiacre.LocalPortsDeclaration;
import fr.irit.fiacre.xtext.fiacre.LoopStatement;
import fr.irit.fiacre.xtext.fiacre.Model;
import fr.irit.fiacre.xtext.fiacre.Modulo;
import fr.irit.fiacre.xtext.fiacre.MortalPattern;
import fr.irit.fiacre.xtext.fiacre.Multiplication;
import fr.irit.fiacre.xtext.fiacre.NamedItem;
import fr.irit.fiacre.xtext.fiacre.NaturalItem;
import fr.irit.fiacre.xtext.fiacre.NaturalLiteral;
import fr.irit.fiacre.xtext.fiacre.NaturalLowerBound;
import fr.irit.fiacre.xtext.fiacre.NaturalType;
import fr.irit.fiacre.xtext.fiacre.NaturalUpperBound;
import fr.irit.fiacre.xtext.fiacre.NullStatement;
import fr.irit.fiacre.xtext.fiacre.ObservableConjunction;
import fr.irit.fiacre.xtext.fiacre.ObservableDisjunction;
import fr.irit.fiacre.xtext.fiacre.ObservableImplication;
import fr.irit.fiacre.xtext.fiacre.ObservableNegation;
import fr.irit.fiacre.xtext.fiacre.OnStatement;
import fr.irit.fiacre.xtext.fiacre.ParameterDeclaration;
import fr.irit.fiacre.xtext.fiacre.ParametersDeclaration;
import fr.irit.fiacre.xtext.fiacre.Path;
import fr.irit.fiacre.xtext.fiacre.PathEvent;
import fr.irit.fiacre.xtext.fiacre.PortDeclaration;
import fr.irit.fiacre.xtext.fiacre.PortSet;
import fr.irit.fiacre.xtext.fiacre.PortsDeclaration;
import fr.irit.fiacre.xtext.fiacre.PrecedesPattern;
import fr.irit.fiacre.xtext.fiacre.PresencePattern;
import fr.irit.fiacre.xtext.fiacre.PriorityDeclaration;
import fr.irit.fiacre.xtext.fiacre.PriorityGroup;
import fr.irit.fiacre.xtext.fiacre.ProcessDeclaration;
import fr.irit.fiacre.xtext.fiacre.Projection;
import fr.irit.fiacre.xtext.fiacre.PropertyConjunction;
import fr.irit.fiacre.xtext.fiacre.PropertyDeclaration;
import fr.irit.fiacre.xtext.fiacre.PropertyDisjunction;
import fr.irit.fiacre.xtext.fiacre.PropertyImplication;
import fr.irit.fiacre.xtext.fiacre.PropertyNegation;
import fr.irit.fiacre.xtext.fiacre.QueueExpression;
import fr.irit.fiacre.xtext.fiacre.QueueType;
import fr.irit.fiacre.xtext.fiacre.RangeType;
import fr.irit.fiacre.xtext.fiacre.ReceiveStatement;
import fr.irit.fiacre.xtext.fiacre.RecordAccessExpression;
import fr.irit.fiacre.xtext.fiacre.RecordAccessPattern;
import fr.irit.fiacre.xtext.fiacre.RecordExpression;
import fr.irit.fiacre.xtext.fiacre.RecordFieldDeclaration;
import fr.irit.fiacre.xtext.fiacre.RecordFields;
import fr.irit.fiacre.xtext.fiacre.RecordType;
import fr.irit.fiacre.xtext.fiacre.ReferenceExpression;
import fr.irit.fiacre.xtext.fiacre.ReferencedType;
import fr.irit.fiacre.xtext.fiacre.Requirement;
import fr.irit.fiacre.xtext.fiacre.ReturnStatement;
import fr.irit.fiacre.xtext.fiacre.Root;
import fr.irit.fiacre.xtext.fiacre.SelectStatement;
import fr.irit.fiacre.xtext.fiacre.SendStatement;
import fr.irit.fiacre.xtext.fiacre.StateDeclaration;
import fr.irit.fiacre.xtext.fiacre.StateSubject;
import fr.irit.fiacre.xtext.fiacre.StatementChoice;
import fr.irit.fiacre.xtext.fiacre.StatementSequence;
import fr.irit.fiacre.xtext.fiacre.Substraction;
import fr.irit.fiacre.xtext.fiacre.TagSubject;
import fr.irit.fiacre.xtext.fiacre.TaggedStatement;
import fr.irit.fiacre.xtext.fiacre.ToStatement;
import fr.irit.fiacre.xtext.fiacre.Transition;
import fr.irit.fiacre.xtext.fiacre.TransitionSource;
import fr.irit.fiacre.xtext.fiacre.TrueLiteral;
import fr.irit.fiacre.xtext.fiacre.TupleType;
import fr.irit.fiacre.xtext.fiacre.TypeDeclaration;
import fr.irit.fiacre.xtext.fiacre.UnaryCoerceExpression;
import fr.irit.fiacre.xtext.fiacre.UnaryDeQueueExpression;
import fr.irit.fiacre.xtext.fiacre.UnaryEmptyExpression;
import fr.irit.fiacre.xtext.fiacre.UnaryFirstExpression;
import fr.irit.fiacre.xtext.fiacre.UnaryFullExpression;
import fr.irit.fiacre.xtext.fiacre.UnaryLengthExpression;
import fr.irit.fiacre.xtext.fiacre.UnaryMinusExpression;
import fr.irit.fiacre.xtext.fiacre.UnaryNegationExpression;
import fr.irit.fiacre.xtext.fiacre.UnaryPlusExpression;
import fr.irit.fiacre.xtext.fiacre.UnionTagDeclaration;
import fr.irit.fiacre.xtext.fiacre.UnionTags;
import fr.irit.fiacre.xtext.fiacre.UnionType;
import fr.irit.fiacre.xtext.fiacre.UnlessStatement;
import fr.irit.fiacre.xtext.fiacre.ValueSubject;
import fr.irit.fiacre.xtext.fiacre.VariableDeclaration;
import fr.irit.fiacre.xtext.fiacre.VariableLowerBound;
import fr.irit.fiacre.xtext.fiacre.VariableUpperBound;
import fr.irit.fiacre.xtext.fiacre.VariablesDeclaration;
import fr.irit.fiacre.xtext.fiacre.WaitStatement;
import fr.irit.fiacre.xtext.fiacre.WhileStatement;
import fr.irit.fiacre.xtext.services.FiacreGrammarAccess;
import java.util.Set;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.xtext.Action;
import org.eclipse.xtext.Parameter;
import org.eclipse.xtext.ParserRule;
import org.eclipse.xtext.serializer.ISerializationContext;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public class FiacreSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private FiacreGrammarAccess 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 == FiacrePackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case FiacrePackage.ABSENCE_PATTERN:
				sequence_AbsencePattern(context, (AbsencePattern) semanticObject); 
				return; 
			case FiacrePackage.ADDITION:
				sequence_Addition(context, (Addition) semanticObject); 
				return; 
			case FiacrePackage.ALL_EXPRESSION:
				sequence_QuantifiedExpression(context, (AllExpression) semanticObject); 
				return; 
			case FiacrePackage.ALL_PROPERTY:
				sequence_QuantifiedProperty(context, (AllProperty) semanticObject); 
				return; 
			case FiacrePackage.ALWAYS_PATTERN:
				sequence_AlwaysPattern(context, (AlwaysPattern) semanticObject); 
				return; 
			case FiacrePackage.ANY_PATTERN:
				sequence_AnyPattern(context, (AnyPattern) semanticObject); 
				return; 
			case FiacrePackage.APPEND_EXPRESSION:
				sequence_AppendExpression(context, (AppendExpression) semanticObject); 
				return; 
			case FiacrePackage.ARRAY_ACCESS_EXPRESSION:
				sequence_IdentifierExpression(context, (ArrayAccessExpression) semanticObject); 
				return; 
			case FiacrePackage.ARRAY_ACCESS_PATTERN:
				sequence_IdentifierPattern(context, (ArrayAccessPattern) semanticObject); 
				return; 
			case FiacrePackage.ARRAY_EXPRESSION:
				sequence_ArrayExpression(context, (ArrayExpression) semanticObject); 
				return; 
			case FiacrePackage.ARRAY_TYPE:
				sequence_ArrayType(context, (ArrayType) semanticObject); 
				return; 
			case FiacrePackage.ASSIGN_ANY_STATEMENT:
				sequence_PatternStatement(context, (AssignAnyStatement) semanticObject); 
				return; 
			case FiacrePackage.ASSIGN_STATEMENT:
				sequence_PatternStatement(context, (AssignStatement) semanticObject); 
				return; 
			case FiacrePackage.BLOCK_STATEMENT:
				sequence_BlockStatement(context, (BlockStatement) semanticObject); 
				return; 
			case FiacrePackage.BOOLEAN_TYPE:
				sequence_BasicType(context, (BooleanType) semanticObject); 
				return; 
			case FiacrePackage.CASE_STATEMENT:
				sequence_CaseStatement(context, (CaseStatement) semanticObject); 
				return; 
			case FiacrePackage.CHANNEL_DECLARATION:
				sequence_ChannelDeclaration(context, (ChannelDeclaration) semanticObject); 
				return; 
			case FiacrePackage.CHANNEL_TYPE:
				sequence_ChannelType(context, (ChannelType) semanticObject); 
				return; 
			case FiacrePackage.COMPARISON_EQUAL:
				sequence_Comparison(context, (ComparisonEqual) semanticObject); 
				return; 
			case FiacrePackage.COMPARISON_GREATER:
				sequence_Comparison(context, (ComparisonGreater) semanticObject); 
				return; 
			case FiacrePackage.COMPARISON_GREATER_EQUAL:
				sequence_Comparison(context, (ComparisonGreaterEqual) semanticObject); 
				return; 
			case FiacrePackage.COMPARISON_LESSER:
				sequence_Comparison(context, (ComparisonLesser) semanticObject); 
				return; 
			case FiacrePackage.COMPARISON_LESSER_EQUAL:
				sequence_Comparison(context, (ComparisonLesserEqual) semanticObject); 
				return; 
			case FiacrePackage.COMPARISON_NOT_EQUAL:
				sequence_Comparison(context, (ComparisonNotEqual) semanticObject); 
				return; 
			case FiacrePackage.COMPONENT_DECLARATION:
				sequence_ComponentDeclaration(context, (ComponentDeclaration) semanticObject); 
				return; 
			case FiacrePackage.COMPONENT_INSTANCE:
				sequence_ComponentInstance(context, (ComponentInstance) semanticObject); 
				return; 
			case FiacrePackage.COMPOSITE_BLOCK:
				sequence_CompositeBlock(context, (CompositeBlock) semanticObject); 
				return; 
			case FiacrePackage.COMPOSITION:
				sequence_Composition(context, (Composition) semanticObject); 
				return; 
			case FiacrePackage.CONDITIONAL:
				sequence_Conditional(context, (Conditional) semanticObject); 
				return; 
			case FiacrePackage.CONDITIONAL_STATEMENT:
				sequence_ConditionalStatement(context, (ConditionalStatement) semanticObject); 
				return; 
			case FiacrePackage.CONJUNCTION:
				sequence_Conjunction(context, (Conjunction) semanticObject); 
				return; 
			case FiacrePackage.CONSTANT_DECLARATION:
				sequence_ConstantDeclaration(context, (ConstantDeclaration) semanticObject); 
				return; 
			case FiacrePackage.CONSTANT_PATTERN:
				sequence_ConstantPattern(context, (ConstantPattern) semanticObject); 
				return; 
			case FiacrePackage.CONSTRUCTION_EXPRESSION:
				sequence_IdentifierExpression(context, (ConstructionExpression) semanticObject); 
				return; 
			case FiacrePackage.CONSTRUCTOR_PATTERN:
				sequence_IdentifierPattern(context, (ConstructorPattern) semanticObject); 
				return; 
			case FiacrePackage.DEADLOCK_FREE_PATTERN:
				sequence_DeadlockFreePattern(context, (DeadlockFreePattern) semanticObject); 
				return; 
			case FiacrePackage.DECIMAL_LOWER_BOUND:
				sequence_DecimalLowerBound(context, (DecimalLowerBound) semanticObject); 
				return; 
			case FiacrePackage.DECIMAL_UPPER_BOUND:
				sequence_DecimalUpperBound(context, (DecimalUpperBound) semanticObject); 
				return; 
			case FiacrePackage.DISJUNCTION:
				sequence_Disjunction(context, (Disjunction) semanticObject); 
				return; 
			case FiacrePackage.DIVISION:
				sequence_Division(context, (Division) semanticObject); 
				return; 
			case FiacrePackage.ENQUEUE_EXPRESSION:
				sequence_EnqueueExpression(context, (EnqueueExpression) semanticObject); 
				return; 
			case FiacrePackage.ENTER_STATE_EVENT:
				sequence_EnterStateEvent(context, (EnterStateEvent) semanticObject); 
				return; 
			case FiacrePackage.EVENT_SUBJECT:
				sequence_EventSubject(context, (EventSubject) semanticObject); 
				return; 
			case FiacrePackage.EXISTS_EXPRESSION:
				sequence_QuantifiedExpression(context, (ExistsExpression) semanticObject); 
				return; 
			case FiacrePackage.EXISTS_PROPERTY:
				sequence_QuantifiedProperty(context, (ExistsProperty) semanticObject); 
				return; 
			case FiacrePackage.EXTENDED_CONDITIONAL_STATEMENT:
				sequence_ExtendedConditionalStatement(context, (ExtendedConditionalStatement) semanticObject); 
				return; 
			case FiacrePackage.FALSE_LITERAL:
				sequence_BooleanLiteral(context, (FalseLiteral) semanticObject); 
				return; 
			case FiacrePackage.FIELD_EXPRESSION:
				sequence_FieldExpression(context, (FieldExpression) semanticObject); 
				return; 
			case FiacrePackage.FOREACH_STATEMENT:
				sequence_ForeachStatement(context, (ForeachStatement) semanticObject); 
				return; 
			case FiacrePackage.FUNCTION_DECLARATION:
				sequence_FunctionDeclaration(context, (FunctionDeclaration) semanticObject); 
				return; 
			case FiacrePackage.IDENTIFIER_EXPRESSION:
				sequence_IdentifierExpression(context, (IdentifierExpression) semanticObject); 
				return; 
			case FiacrePackage.IDENTIFIER_PATTERN:
				sequence_IdentifierPattern(context, (IdentifierPattern) semanticObject); 
				return; 
			case FiacrePackage.IMPLICATION:
				sequence_Implication(context, (Implication) semanticObject); 
				return; 
			case FiacrePackage.IMPORT_DECLARATION:
				sequence_ImportDeclaration(context, (ImportDeclaration) semanticObject); 
				return; 
			case FiacrePackage.INFINITE_UPPER_BOUND:
				sequence_InfiniteUpperBound(context, (InfiniteUpperBound) semanticObject); 
				return; 
			case FiacrePackage.INFINITELY_OFTEN_PATTERN:
				sequence_InfinitelyOftenPattern(context, (InfinitelyOftenPattern) semanticObject); 
				return; 
			case FiacrePackage.INSTANCE_DECLARATION:
				sequence_InstanceDeclaration(context, (InstanceDeclaration) semanticObject); 
				return; 
			case FiacrePackage.INTEGER_PATTERN:
				sequence_IntegerPattern(context, (IntegerPattern) semanticObject); 
				return; 
			case FiacrePackage.INTEGER_TYPE:
				sequence_BasicType(context, (IntegerType) semanticObject); 
				return; 
			case FiacrePackage.LTL_ALL:
				sequence_LTLQuantified(context, (LTLAll) semanticObject); 
				return; 
			case FiacrePackage.LTL_CONJUNCTION:
				sequence_LTLConjunction(context, (LTLConjunction) semanticObject); 
				return; 
			case FiacrePackage.LTL_DISJUNCTION:
				sequence_LTLDisjunction(context, (LTLDisjunction) semanticObject); 
				return; 
			case FiacrePackage.LTL_EXISTS:
				sequence_LTLQuantified(context, (LTLExists) semanticObject); 
				return; 
			case FiacrePackage.LTL_IMPLICATION:
				sequence_LTLImplication(context, (LTLImplication) semanticObject); 
				return; 
			case FiacrePackage.LTL_PATTERN:
				sequence_LTLPattern(context, (LTLPattern) semanticObject); 
				return; 
			case FiacrePackage.LTL_RELEASE:
				sequence_LTLBinary(context, (LTLRelease) semanticObject); 
				return; 
			case FiacrePackage.LTL_UNARY_ALWAYS:
				sequence_LTLUnary(context, (LTLUnaryAlways) semanticObject); 
				return; 
			case FiacrePackage.LTL_UNARY_EVENTUALLY:
				sequence_LTLUnary(context, (LTLUnaryEventually) semanticObject); 
				return; 
			case FiacrePackage.LTL_UNARY_NEGATION:
				sequence_LTLUnary(context, (LTLUnaryNegation) semanticObject); 
				return; 
			case FiacrePackage.LTL_UNARY_NEXT:
				sequence_LTLUnary(context, (LTLUnaryNext) semanticObject); 
				return; 
			case FiacrePackage.LTL_UNTIL:
				sequence_LTLBinary(context, (LTLUntil) semanticObject); 
				return; 
			case FiacrePackage.LTL_VARIABLE:
				sequence_AtomicLTL(context, (LTLVariable) semanticObject); 
				return; 
			case FiacrePackage.LEADS_TO_PATTERN:
				sequence_SequencePattern(context, (LeadsToPattern) semanticObject); 
				return; 
			case FiacrePackage.LEAVE_STATE_EVENT:
				sequence_LeaveStateEvent(context, (LeaveStateEvent) semanticObject); 
				return; 
			case FiacrePackage.LOCAL_PORTS_DECLARATION:
				sequence_LocalPortsDeclaration(context, (LocalPortsDeclaration) semanticObject); 
				return; 
			case FiacrePackage.LOOP_STATEMENT:
				sequence_LoopStatement(context, (LoopStatement) semanticObject); 
				return; 
			case FiacrePackage.MODEL:
				sequence_Model(context, (Model) semanticObject); 
				return; 
			case FiacrePackage.MODULO:
				sequence_Modulo(context, (Modulo) semanticObject); 
				return; 
			case FiacrePackage.MORTAL_PATTERN:
				sequence_MortalPattern(context, (MortalPattern) semanticObject); 
				return; 
			case FiacrePackage.MULTIPLICATION:
				sequence_Multiplication(context, (Multiplication) semanticObject); 
				return; 
			case FiacrePackage.NAMED_ITEM:
				sequence_NamedItem(context, (NamedItem) semanticObject); 
				return; 
			case FiacrePackage.NATURAL_ITEM:
				sequence_NaturalItem(context, (NaturalItem) semanticObject); 
				return; 
			case FiacrePackage.NATURAL_LITERAL:
				sequence_NaturalLiteral(context, (NaturalLiteral) semanticObject); 
				return; 
			case FiacrePackage.NATURAL_LOWER_BOUND:
				sequence_NaturalLowerBound(context, (NaturalLowerBound) semanticObject); 
				return; 
			case FiacrePackage.NATURAL_TYPE:
				sequence_BasicType(context, (NaturalType) semanticObject); 
				return; 
			case FiacrePackage.NATURAL_UPPER_BOUND:
				sequence_NaturalUpperBound(context, (NaturalUpperBound) semanticObject); 
				return; 
			case FiacrePackage.NULL_STATEMENT:
				sequence_NullStatement(context, (NullStatement) semanticObject); 
				return; 
			case FiacrePackage.OBSERVABLE_CONJUNCTION:
				sequence_ObservableConjunction(context, (ObservableConjunction) semanticObject); 
				return; 
			case FiacrePackage.OBSERVABLE_DISJUNCTION:
				sequence_ObservableDisjunction(context, (ObservableDisjunction) semanticObject); 
				return; 
			case FiacrePackage.OBSERVABLE_IMPLICATION:
				sequence_ObservableImplication(context, (ObservableImplication) semanticObject); 
				return; 
			case FiacrePackage.OBSERVABLE_NEGATION:
				sequence_ObservableNegation(context, (ObservableNegation) semanticObject); 
				return; 
			case FiacrePackage.ON_STATEMENT:
				sequence_OnStatement(context, (OnStatement) semanticObject); 
				return; 
			case FiacrePackage.PARAMETER_DECLARATION:
				sequence_ParameterDeclaration(context, (ParameterDeclaration) semanticObject); 
				return; 
			case FiacrePackage.PARAMETERS_DECLARATION:
				sequence_ParametersDeclaration(context, (ParametersDeclaration) semanticObject); 
				return; 
			case FiacrePackage.PATH:
				sequence_Path(context, (Path) semanticObject); 
				return; 
			case FiacrePackage.PATH_EVENT:
				sequence_PathEvent(context, (PathEvent) semanticObject); 
				return; 
			case FiacrePackage.PORT_DECLARATION:
				sequence_PortDeclaration(context, (PortDeclaration) semanticObject); 
				return; 
			case FiacrePackage.PORT_SET:
				sequence_PortSet(context, (PortSet) semanticObject); 
				return; 
			case FiacrePackage.PORTS_DECLARATION:
				sequence_PortsDeclaration(context, (PortsDeclaration) semanticObject); 
				return; 
			case FiacrePackage.PRECEDES_PATTERN:
				sequence_SequencePattern(context, (PrecedesPattern) semanticObject); 
				return; 
			case FiacrePackage.PRESENCE_PATTERN:
				sequence_PresencePattern(context, (PresencePattern) semanticObject); 
				return; 
			case FiacrePackage.PRIORITY_DECLARATION:
				sequence_PriorityDeclaration(context, (PriorityDeclaration) semanticObject); 
				return; 
			case FiacrePackage.PRIORITY_GROUP:
				sequence_PriorityGroup(context, (PriorityGroup) semanticObject); 
				return; 
			case FiacrePackage.PROCESS_DECLARATION:
				sequence_ProcessDeclaration(context, (ProcessDeclaration) semanticObject); 
				return; 
			case FiacrePackage.PROJECTION:
				sequence_Projection(context, (Projection) semanticObject); 
				return; 
			case FiacrePackage.PROPERTY_CONJUNCTION:
				sequence_PropertyConjunction(context, (PropertyConjunction) semanticObject); 
				return; 
			case FiacrePackage.PROPERTY_DECLARATION:
				sequence_PropertyDeclaration(context, (PropertyDeclaration) semanticObject); 
				return; 
			case FiacrePackage.PROPERTY_DISJUNCTION:
				sequence_PropertyDisjunction(context, (PropertyDisjunction) semanticObject); 
				return; 
			case FiacrePackage.PROPERTY_IMPLICATION:
				sequence_PropertyImplication(context, (PropertyImplication) semanticObject); 
				return; 
			case FiacrePackage.PROPERTY_NEGATION:
				sequence_PropertyNegation(context, (PropertyNegation) semanticObject); 
				return; 
			case FiacrePackage.QUEUE_EXPRESSION:
				sequence_QueueExpression(context, (QueueExpression) semanticObject); 
				return; 
			case FiacrePackage.QUEUE_TYPE:
				sequence_QueueType(context, (QueueType) semanticObject); 
				return; 
			case FiacrePackage.RANGE_TYPE:
				sequence_RangeType(context, (RangeType) semanticObject); 
				return; 
			case FiacrePackage.RECEIVE_STATEMENT:
				sequence_PatternStatement(context, (ReceiveStatement) semanticObject); 
				return; 
			case FiacrePackage.RECORD_ACCESS_EXPRESSION:
				sequence_IdentifierExpression(context, (RecordAccessExpression) semanticObject); 
				return; 
			case FiacrePackage.RECORD_ACCESS_PATTERN:
				sequence_IdentifierPattern(context, (RecordAccessPattern) semanticObject); 
				return; 
			case FiacrePackage.RECORD_EXPRESSION:
				sequence_RecordExpression(context, (RecordExpression) semanticObject); 
				return; 
			case FiacrePackage.RECORD_FIELD_DECLARATION:
				sequence_RecordFieldDeclaration(context, (RecordFieldDeclaration) semanticObject); 
				return; 
			case FiacrePackage.RECORD_FIELDS:
				sequence_RecordFields(context, (RecordFields) semanticObject); 
				return; 
			case FiacrePackage.RECORD_TYPE:
				sequence_RecordType(context, (RecordType) semanticObject); 
				return; 
			case FiacrePackage.REFERENCE_EXPRESSION:
				sequence_ReferenceExpression(context, (ReferenceExpression) semanticObject); 
				return; 
			case FiacrePackage.REFERENCED_TYPE:
				sequence_ReferencedType(context, (ReferencedType) semanticObject); 
				return; 
			case FiacrePackage.REQUIREMENT:
				sequence_Requirement(context, (Requirement) semanticObject); 
				return; 
			case FiacrePackage.RETURN_STATEMENT:
				sequence_ReturnStatement(context, (ReturnStatement) semanticObject); 
				return; 
			case FiacrePackage.ROOT:
				sequence_Root(context, (Root) semanticObject); 
				return; 
			case FiacrePackage.SELECT_STATEMENT:
				sequence_SelectStatement(context, (SelectStatement) semanticObject); 
				return; 
			case FiacrePackage.SEND_STATEMENT:
				sequence_PatternStatement(context, (SendStatement) semanticObject); 
				return; 
			case FiacrePackage.STATE_DECLARATION:
				sequence_StateDeclaration(context, (StateDeclaration) semanticObject); 
				return; 
			case FiacrePackage.STATE_SUBJECT:
				sequence_StateSubject(context, (StateSubject) semanticObject); 
				return; 
			case FiacrePackage.STATEMENT_CHOICE:
				sequence_StatementChoice(context, (StatementChoice) semanticObject); 
				return; 
			case FiacrePackage.STATEMENT_SEQUENCE:
				sequence_StatementSequence(context, (StatementSequence) semanticObject); 
				return; 
			case FiacrePackage.SUBSTRACTION:
				sequence_Substraction(context, (Substraction) semanticObject); 
				return; 
			case FiacrePackage.TAG_SUBJECT:
				sequence_TagSubject(context, (TagSubject) semanticObject); 
				return; 
			case FiacrePackage.TAGGED_STATEMENT:
				sequence_TaggedStatement(context, (TaggedStatement) semanticObject); 
				return; 
			case FiacrePackage.TO_STATEMENT:
				sequence_ToStatement(context, (ToStatement) semanticObject); 
				return; 
			case FiacrePackage.TRANSITION:
				sequence_Transition(context, (Transition) semanticObject); 
				return; 
			case FiacrePackage.TRANSITION_SOURCE:
				sequence_TransitionSource(context, (TransitionSource) semanticObject); 
				return; 
			case FiacrePackage.TRUE_LITERAL:
				sequence_BooleanLiteral(context, (TrueLiteral) semanticObject); 
				return; 
			case FiacrePackage.TUPLE_TYPE:
				sequence_TupleType(context, (TupleType) semanticObject); 
				return; 
			case FiacrePackage.TYPE_DECLARATION:
				sequence_TypeDeclaration(context, (TypeDeclaration) semanticObject); 
				return; 
			case FiacrePackage.UNARY_COERCE_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryCoerceExpression) semanticObject); 
				return; 
			case FiacrePackage.UNARY_DE_QUEUE_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryDeQueueExpression) semanticObject); 
				return; 
			case FiacrePackage.UNARY_EMPTY_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryEmptyExpression) semanticObject); 
				return; 
			case FiacrePackage.UNARY_FIRST_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryFirstExpression) semanticObject); 
				return; 
			case FiacrePackage.UNARY_FULL_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryFullExpression) semanticObject); 
				return; 
			case FiacrePackage.UNARY_LENGTH_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryLengthExpression) semanticObject); 
				return; 
			case FiacrePackage.UNARY_MINUS_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryMinusExpression) semanticObject); 
				return; 
			case FiacrePackage.UNARY_NEGATION_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryNegationExpression) semanticObject); 
				return; 
			case FiacrePackage.UNARY_PLUS_EXPRESSION:
				sequence_UnaryExpression(context, (UnaryPlusExpression) semanticObject); 
				return; 
			case FiacrePackage.UNION_TAG_DECLARATION:
				sequence_UnionTagDeclaration(context, (UnionTagDeclaration) semanticObject); 
				return; 
			case FiacrePackage.UNION_TAGS:
				sequence_UnionTags(context, (UnionTags) semanticObject); 
				return; 
			case FiacrePackage.UNION_TYPE:
				sequence_UnionType(context, (UnionType) semanticObject); 
				return; 
			case FiacrePackage.UNLESS_STATEMENT:
				sequence_UnlessStatement(context, (UnlessStatement) semanticObject); 
				return; 
			case FiacrePackage.VALUE_SUBJECT:
				sequence_ValueSubject(context, (ValueSubject) semanticObject); 
				return; 
			case FiacrePackage.VARIABLE_DECLARATION:
				sequence_VariableDeclaration(context, (VariableDeclaration) semanticObject); 
				return; 
			case FiacrePackage.VARIABLE_LOWER_BOUND:
				sequence_VariableLowerBound(context, (VariableLowerBound) semanticObject); 
				return; 
			case FiacrePackage.VARIABLE_UPPER_BOUND:
				sequence_VariableUpperBound(context, (VariableUpperBound) semanticObject); 
				return; 
			case FiacrePackage.VARIABLES_DECLARATION:
				sequence_VariablesDeclaration(context, (VariablesDeclaration) semanticObject); 
				return; 
			case FiacrePackage.WAIT_STATEMENT:
				sequence_WaitStatement(context, (WaitStatement) semanticObject); 
				return; 
			case FiacrePackage.WHILE_STATEMENT:
				sequence_WhileStatement(context, (WhileStatement) semanticObject); 
				return; 
			}
		if (errorAcceptor != null)
			errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Contexts:
	 *     Property returns AbsencePattern
	 *     QuantifiedProperty returns AbsencePattern
	 *     PropertyDisjunction returns AbsencePattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns AbsencePattern
	 *     PropertyImplication returns AbsencePattern
	 *     PropertyImplication.PropertyImplication_1_0 returns AbsencePattern
	 *     PropertyConjunction returns AbsencePattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns AbsencePattern
	 *     PropertyNegation returns AbsencePattern
	 *     AtomicProperty returns AbsencePattern
	 *     PatternProperty returns AbsencePattern
	 *     AbsencePattern returns AbsencePattern
	 *
	 * Constraint:
	 *     (
	 *         subject=AtomicObservable 
	 *         (
	 *             (after=AtomicObservable ((lower=LowerBound upper=UpperBound) | until=AtomicObservable)?) | 
	 *             (before=AtomicObservable (lower=LowerBound upper=UpperBound)?) | 
	 *             (min=AtomicObservable max=AtomicObservable)
	 *         )?
	 *     )
	 */
	protected void sequence_AbsencePattern(ISerializationContext context, AbsencePattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Addition
	 *     QuantifiedExpression returns Addition
	 *     Conditional returns Addition
	 *     Conditional.Conditional_1_1 returns Addition
	 *     Disjunction returns Addition
	 *     Disjunction.Disjunction_1_0 returns Addition
	 *     Implication returns Addition
	 *     Implication.Implication_1_0 returns Addition
	 *     Conjunction returns Addition
	 *     Conjunction.Conjunction_1_0 returns Addition
	 *     Comparison returns Addition
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Addition
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Addition
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Addition
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Addition
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Addition
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Addition
	 *     Addition returns Addition
	 *     Addition.Addition_1_0 returns Addition
	 *     Substraction returns Addition
	 *     Substraction.Substraction_1_0 returns Addition
	 *     Multiplication returns Addition
	 *     Multiplication.Multiplication_1_0 returns Addition
	 *     Division returns Addition
	 *     Division.Division_1_0 returns Addition
	 *     Modulo returns Addition
	 *     Modulo.Modulo_1_0 returns Addition
	 *     UnaryExpression returns Addition
	 *     Projection returns Addition
	 *     Projection.Projection_1_0 returns Addition
	 *     AtomicExpression returns Addition
	 *
	 * Constraint:
	 *     (left=Addition_Addition_1_0 right=Substraction)
	 */
	protected void sequence_Addition(ISerializationContext context, Addition semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getAddition_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getAddition_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getAddition_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getAddition_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAdditionAccess().getAdditionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getAdditionAccess().getRightSubstractionParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns AlwaysPattern
	 *     QuantifiedProperty returns AlwaysPattern
	 *     PropertyDisjunction returns AlwaysPattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns AlwaysPattern
	 *     PropertyImplication returns AlwaysPattern
	 *     PropertyImplication.PropertyImplication_1_0 returns AlwaysPattern
	 *     PropertyConjunction returns AlwaysPattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns AlwaysPattern
	 *     PropertyNegation returns AlwaysPattern
	 *     AtomicProperty returns AlwaysPattern
	 *     PatternProperty returns AlwaysPattern
	 *     AlwaysPattern returns AlwaysPattern
	 *
	 * Constraint:
	 *     (
	 *         subject=AtomicObservable 
	 *         (before=AtomicObservable | (after=AtomicObservable until=AtomicObservable?) | (min=AtomicObservable max=AtomicObservable))?
	 *     )
	 */
	protected void sequence_AlwaysPattern(ISerializationContext context, AlwaysPattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns AnyPattern
	 *     UnlessStatement.UnlessStatement_1_0 returns AnyPattern
	 *     StatementChoice returns AnyPattern
	 *     StatementChoice.StatementChoice_1_0 returns AnyPattern
	 *     StatementSequence returns AnyPattern
	 *     StatementSequence.StatementSequence_1_0 returns AnyPattern
	 *     Statement returns AnyPattern
	 *     PatternStatement returns AnyPattern
	 *     PatternStatement.AssignStatement_1_0_1 returns AnyPattern
	 *     PatternStatement.AssignStatement_1_1_1 returns AnyPattern
	 *     PatternStatement.AssignAnyStatement_1_2_1 returns AnyPattern
	 *     PatternStatement.AssignAnyStatement_1_3_1 returns AnyPattern
	 *     PatternStatement.SendStatement_1_4_1 returns AnyPattern
	 *     PatternStatement.ReceiveStatement_1_5_1 returns AnyPattern
	 *     Pattern returns AnyPattern
	 *     AnyPattern returns AnyPattern
	 *
	 * Constraint:
	 *     {AnyPattern}
	 */
	protected void sequence_AnyPattern(ISerializationContext context, AnyPattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns AppendExpression
	 *     QuantifiedExpression returns AppendExpression
	 *     Conditional returns AppendExpression
	 *     Conditional.Conditional_1_1 returns AppendExpression
	 *     Disjunction returns AppendExpression
	 *     Disjunction.Disjunction_1_0 returns AppendExpression
	 *     Implication returns AppendExpression
	 *     Implication.Implication_1_0 returns AppendExpression
	 *     Conjunction returns AppendExpression
	 *     Conjunction.Conjunction_1_0 returns AppendExpression
	 *     Comparison returns AppendExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns AppendExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns AppendExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns AppendExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns AppendExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns AppendExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns AppendExpression
	 *     Addition returns AppendExpression
	 *     Addition.Addition_1_0 returns AppendExpression
	 *     Substraction returns AppendExpression
	 *     Substraction.Substraction_1_0 returns AppendExpression
	 *     Multiplication returns AppendExpression
	 *     Multiplication.Multiplication_1_0 returns AppendExpression
	 *     Division returns AppendExpression
	 *     Division.Division_1_0 returns AppendExpression
	 *     Modulo returns AppendExpression
	 *     Modulo.Modulo_1_0 returns AppendExpression
	 *     UnaryExpression returns AppendExpression
	 *     Projection returns AppendExpression
	 *     Projection.Projection_1_0 returns AppendExpression
	 *     AtomicExpression returns AppendExpression
	 *     AppendExpression returns AppendExpression
	 *
	 * Constraint:
	 *     (left=Expression right=Expression)
	 */
	protected void sequence_AppendExpression(ISerializationContext context, AppendExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getAppendExpression_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getAppendExpression_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getAppendExpression_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getAppendExpression_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAppendExpressionAccess().getLeftExpressionParserRuleCall_2_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getAppendExpressionAccess().getRightExpressionParserRuleCall_4_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ArrayExpression
	 *     QuantifiedExpression returns ArrayExpression
	 *     Conditional returns ArrayExpression
	 *     Conditional.Conditional_1_1 returns ArrayExpression
	 *     Disjunction returns ArrayExpression
	 *     Disjunction.Disjunction_1_0 returns ArrayExpression
	 *     Implication returns ArrayExpression
	 *     Implication.Implication_1_0 returns ArrayExpression
	 *     Conjunction returns ArrayExpression
	 *     Conjunction.Conjunction_1_0 returns ArrayExpression
	 *     Comparison returns ArrayExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ArrayExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ArrayExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ArrayExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ArrayExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ArrayExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ArrayExpression
	 *     Addition returns ArrayExpression
	 *     Addition.Addition_1_0 returns ArrayExpression
	 *     Substraction returns ArrayExpression
	 *     Substraction.Substraction_1_0 returns ArrayExpression
	 *     Multiplication returns ArrayExpression
	 *     Multiplication.Multiplication_1_0 returns ArrayExpression
	 *     Division returns ArrayExpression
	 *     Division.Division_1_0 returns ArrayExpression
	 *     Modulo returns ArrayExpression
	 *     Modulo.Modulo_1_0 returns ArrayExpression
	 *     UnaryExpression returns ArrayExpression
	 *     Projection returns ArrayExpression
	 *     Projection.Projection_1_0 returns ArrayExpression
	 *     ValueExpression returns ArrayExpression
	 *     AtomicExpression returns ArrayExpression
	 *     ArrayExpression returns ArrayExpression
	 *
	 * Constraint:
	 *     (values+=Expression values+=Expression*)?
	 */
	protected void sequence_ArrayExpression(ISerializationContext context, ArrayExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Type returns ArrayType
	 *     TupleType returns ArrayType
	 *     TupleType.TupleType_1_0 returns ArrayType
	 *     ArrayType returns ArrayType
	 *
	 * Constraint:
	 *     (size=Expression type=Type)
	 */
	protected void sequence_ArrayType(ISerializationContext context, ArrayType semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getArrayType_Size()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getArrayType_Size()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getArrayType_Type()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getArrayType_Type()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getArrayTypeAccess().getSizeExpressionParserRuleCall_1_0(), semanticObject.getSize());
		feeder.accept(grammarAccess.getArrayTypeAccess().getTypeTypeParserRuleCall_3_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLVariable
	 *     LTLQuantified returns LTLVariable
	 *     LTLDisjunction returns LTLVariable
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLVariable
	 *     LTLImplication returns LTLVariable
	 *     LTLImplication.LTLImplication_1_0 returns LTLVariable
	 *     LTLConjunction returns LTLVariable
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLVariable
	 *     LTLBinary returns LTLVariable
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLVariable
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLVariable
	 *     LTLUnary returns LTLVariable
	 *     AtomicLTL returns LTLVariable
	 *
	 * Constraint:
	 *     declaration=[PropertyDeclarationUse|ID]
	 */
	protected void sequence_AtomicLTL(ISerializationContext context, LTLVariable semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLVariable_Declaration()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLVariable_Declaration()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAtomicLTLAccess().getDeclarationPropertyDeclarationUseIDTerminalRuleCall_0_1_0_1(), semanticObject.getDeclaration());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Type returns BooleanType
	 *     TupleType returns BooleanType
	 *     TupleType.TupleType_1_0 returns BooleanType
	 *     BasicType returns BooleanType
	 *
	 * Constraint:
	 *     {BooleanType}
	 */
	protected void sequence_BasicType(ISerializationContext context, BooleanType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Type returns IntegerType
	 *     TupleType returns IntegerType
	 *     TupleType.TupleType_1_0 returns IntegerType
	 *     BasicType returns IntegerType
	 *
	 * Constraint:
	 *     {IntegerType}
	 */
	protected void sequence_BasicType(ISerializationContext context, IntegerType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Type returns NaturalType
	 *     TupleType returns NaturalType
	 *     TupleType.TupleType_1_0 returns NaturalType
	 *     BasicType returns NaturalType
	 *
	 * Constraint:
	 *     {NaturalType}
	 */
	protected void sequence_BasicType(ISerializationContext context, NaturalType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns BlockStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns BlockStatement
	 *     StatementChoice returns BlockStatement
	 *     StatementChoice.StatementChoice_1_0 returns BlockStatement
	 *     StatementSequence returns BlockStatement
	 *     StatementSequence.StatementSequence_1_0 returns BlockStatement
	 *     Statement returns BlockStatement
	 *     BlockStatement returns BlockStatement
	 *
	 * Constraint:
	 *     body=StatementSequence
	 */
	protected void sequence_BlockStatement(ISerializationContext context, BlockStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getBlockStatement_Body()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getBlockStatement_Body()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getBlockStatementAccess().getBodyStatementSequenceParserRuleCall_1_0(), semanticObject.getBody());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns FalseLiteral
	 *     QuantifiedExpression returns FalseLiteral
	 *     Conditional returns FalseLiteral
	 *     Conditional.Conditional_1_1 returns FalseLiteral
	 *     Disjunction returns FalseLiteral
	 *     Disjunction.Disjunction_1_0 returns FalseLiteral
	 *     Implication returns FalseLiteral
	 *     Implication.Implication_1_0 returns FalseLiteral
	 *     Conjunction returns FalseLiteral
	 *     Conjunction.Conjunction_1_0 returns FalseLiteral
	 *     Comparison returns FalseLiteral
	 *     Comparison.ComparisonEqual_1_0_0_0 returns FalseLiteral
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns FalseLiteral
	 *     Comparison.ComparisonLesser_1_0_2_0 returns FalseLiteral
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns FalseLiteral
	 *     Comparison.ComparisonGreater_1_0_4_0 returns FalseLiteral
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns FalseLiteral
	 *     Addition returns FalseLiteral
	 *     Addition.Addition_1_0 returns FalseLiteral
	 *     Substraction returns FalseLiteral
	 *     Substraction.Substraction_1_0 returns FalseLiteral
	 *     Multiplication returns FalseLiteral
	 *     Multiplication.Multiplication_1_0 returns FalseLiteral
	 *     Division returns FalseLiteral
	 *     Division.Division_1_0 returns FalseLiteral
	 *     Modulo returns FalseLiteral
	 *     Modulo.Modulo_1_0 returns FalseLiteral
	 *     UnaryExpression returns FalseLiteral
	 *     Projection returns FalseLiteral
	 *     Projection.Projection_1_0 returns FalseLiteral
	 *     ValueExpression returns FalseLiteral
	 *     AtomicExpression returns FalseLiteral
	 *     LiteralExpression returns FalseLiteral
	 *     BooleanLiteral returns FalseLiteral
	 *
	 * Constraint:
	 *     {FalseLiteral}
	 */
	protected void sequence_BooleanLiteral(ISerializationContext context, FalseLiteral semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns TrueLiteral
	 *     QuantifiedExpression returns TrueLiteral
	 *     Conditional returns TrueLiteral
	 *     Conditional.Conditional_1_1 returns TrueLiteral
	 *     Disjunction returns TrueLiteral
	 *     Disjunction.Disjunction_1_0 returns TrueLiteral
	 *     Implication returns TrueLiteral
	 *     Implication.Implication_1_0 returns TrueLiteral
	 *     Conjunction returns TrueLiteral
	 *     Conjunction.Conjunction_1_0 returns TrueLiteral
	 *     Comparison returns TrueLiteral
	 *     Comparison.ComparisonEqual_1_0_0_0 returns TrueLiteral
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns TrueLiteral
	 *     Comparison.ComparisonLesser_1_0_2_0 returns TrueLiteral
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns TrueLiteral
	 *     Comparison.ComparisonGreater_1_0_4_0 returns TrueLiteral
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns TrueLiteral
	 *     Addition returns TrueLiteral
	 *     Addition.Addition_1_0 returns TrueLiteral
	 *     Substraction returns TrueLiteral
	 *     Substraction.Substraction_1_0 returns TrueLiteral
	 *     Multiplication returns TrueLiteral
	 *     Multiplication.Multiplication_1_0 returns TrueLiteral
	 *     Division returns TrueLiteral
	 *     Division.Division_1_0 returns TrueLiteral
	 *     Modulo returns TrueLiteral
	 *     Modulo.Modulo_1_0 returns TrueLiteral
	 *     UnaryExpression returns TrueLiteral
	 *     Projection returns TrueLiteral
	 *     Projection.Projection_1_0 returns TrueLiteral
	 *     ValueExpression returns TrueLiteral
	 *     AtomicExpression returns TrueLiteral
	 *     LiteralExpression returns TrueLiteral
	 *     BooleanLiteral returns TrueLiteral
	 *
	 * Constraint:
	 *     {TrueLiteral}
	 */
	protected void sequence_BooleanLiteral(ISerializationContext context, TrueLiteral semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns CaseStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns CaseStatement
	 *     StatementChoice returns CaseStatement
	 *     StatementChoice.StatementChoice_1_0 returns CaseStatement
	 *     StatementSequence returns CaseStatement
	 *     StatementSequence.StatementSequence_1_0 returns CaseStatement
	 *     Statement returns CaseStatement
	 *     CaseStatement returns CaseStatement
	 *
	 * Constraint:
	 *     (value=Expression pattern+=Pattern body+=StatementSequence (pattern+=Pattern body+=StatementSequence)*)
	 */
	protected void sequence_CaseStatement(ISerializationContext context, CaseStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns ChannelDeclaration
	 *     TypeDeclarationUse returns ChannelDeclaration
	 *     Declaration returns ChannelDeclaration
	 *     ChannelDeclaration returns ChannelDeclaration
	 *
	 * Constraint:
	 *     (name=ID value=ChannelType)
	 */
	protected void sequence_ChannelDeclaration(ISerializationContext context, ChannelDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getChannelDeclaration_Value()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getChannelDeclaration_Value()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getChannelDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getChannelDeclarationAccess().getValueChannelTypeParserRuleCall_3_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ChannelType returns ChannelType
	 *
	 * Constraint:
	 *     (size=Expression? ((in?='in' out?='out'?) | out?='out')? type=TupleType?)
	 */
	protected void sequence_ChannelType(ISerializationContext context, ChannelType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ComparisonEqual
	 *     QuantifiedExpression returns ComparisonEqual
	 *     Conditional returns ComparisonEqual
	 *     Conditional.Conditional_1_1 returns ComparisonEqual
	 *     Disjunction returns ComparisonEqual
	 *     Disjunction.Disjunction_1_0 returns ComparisonEqual
	 *     Implication returns ComparisonEqual
	 *     Implication.Implication_1_0 returns ComparisonEqual
	 *     Conjunction returns ComparisonEqual
	 *     Conjunction.Conjunction_1_0 returns ComparisonEqual
	 *     Comparison returns ComparisonEqual
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ComparisonEqual
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ComparisonEqual
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ComparisonEqual
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ComparisonEqual
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ComparisonEqual
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ComparisonEqual
	 *     Addition returns ComparisonEqual
	 *     Addition.Addition_1_0 returns ComparisonEqual
	 *     Substraction returns ComparisonEqual
	 *     Substraction.Substraction_1_0 returns ComparisonEqual
	 *     Multiplication returns ComparisonEqual
	 *     Multiplication.Multiplication_1_0 returns ComparisonEqual
	 *     Division returns ComparisonEqual
	 *     Division.Division_1_0 returns ComparisonEqual
	 *     Modulo returns ComparisonEqual
	 *     Modulo.Modulo_1_0 returns ComparisonEqual
	 *     UnaryExpression returns ComparisonEqual
	 *     Projection returns ComparisonEqual
	 *     Projection.Projection_1_0 returns ComparisonEqual
	 *     AtomicExpression returns ComparisonEqual
	 *
	 * Constraint:
	 *     (left=Comparison_ComparisonEqual_1_0_0_0 right=Addition)
	 */
	protected void sequence_Comparison(ISerializationContext context, ComparisonEqual semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonEqual_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonEqual_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonEqual_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonEqual_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getComparisonAccess().getComparisonEqualLeftAction_1_0_0_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getComparisonAccess().getRightAdditionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ComparisonGreater
	 *     QuantifiedExpression returns ComparisonGreater
	 *     Conditional returns ComparisonGreater
	 *     Conditional.Conditional_1_1 returns ComparisonGreater
	 *     Disjunction returns ComparisonGreater
	 *     Disjunction.Disjunction_1_0 returns ComparisonGreater
	 *     Implication returns ComparisonGreater
	 *     Implication.Implication_1_0 returns ComparisonGreater
	 *     Conjunction returns ComparisonGreater
	 *     Conjunction.Conjunction_1_0 returns ComparisonGreater
	 *     Comparison returns ComparisonGreater
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ComparisonGreater
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ComparisonGreater
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ComparisonGreater
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ComparisonGreater
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ComparisonGreater
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ComparisonGreater
	 *     Addition returns ComparisonGreater
	 *     Addition.Addition_1_0 returns ComparisonGreater
	 *     Substraction returns ComparisonGreater
	 *     Substraction.Substraction_1_0 returns ComparisonGreater
	 *     Multiplication returns ComparisonGreater
	 *     Multiplication.Multiplication_1_0 returns ComparisonGreater
	 *     Division returns ComparisonGreater
	 *     Division.Division_1_0 returns ComparisonGreater
	 *     Modulo returns ComparisonGreater
	 *     Modulo.Modulo_1_0 returns ComparisonGreater
	 *     UnaryExpression returns ComparisonGreater
	 *     Projection returns ComparisonGreater
	 *     Projection.Projection_1_0 returns ComparisonGreater
	 *     AtomicExpression returns ComparisonGreater
	 *
	 * Constraint:
	 *     (left=Comparison_ComparisonGreater_1_0_4_0 right=Addition)
	 */
	protected void sequence_Comparison(ISerializationContext context, ComparisonGreater semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonGreater_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonGreater_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonGreater_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonGreater_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getComparisonAccess().getComparisonGreaterLeftAction_1_0_4_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getComparisonAccess().getRightAdditionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ComparisonGreaterEqual
	 *     QuantifiedExpression returns ComparisonGreaterEqual
	 *     Conditional returns ComparisonGreaterEqual
	 *     Conditional.Conditional_1_1 returns ComparisonGreaterEqual
	 *     Disjunction returns ComparisonGreaterEqual
	 *     Disjunction.Disjunction_1_0 returns ComparisonGreaterEqual
	 *     Implication returns ComparisonGreaterEqual
	 *     Implication.Implication_1_0 returns ComparisonGreaterEqual
	 *     Conjunction returns ComparisonGreaterEqual
	 *     Conjunction.Conjunction_1_0 returns ComparisonGreaterEqual
	 *     Comparison returns ComparisonGreaterEqual
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ComparisonGreaterEqual
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ComparisonGreaterEqual
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ComparisonGreaterEqual
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ComparisonGreaterEqual
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ComparisonGreaterEqual
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ComparisonGreaterEqual
	 *     Addition returns ComparisonGreaterEqual
	 *     Addition.Addition_1_0 returns ComparisonGreaterEqual
	 *     Substraction returns ComparisonGreaterEqual
	 *     Substraction.Substraction_1_0 returns ComparisonGreaterEqual
	 *     Multiplication returns ComparisonGreaterEqual
	 *     Multiplication.Multiplication_1_0 returns ComparisonGreaterEqual
	 *     Division returns ComparisonGreaterEqual
	 *     Division.Division_1_0 returns ComparisonGreaterEqual
	 *     Modulo returns ComparisonGreaterEqual
	 *     Modulo.Modulo_1_0 returns ComparisonGreaterEqual
	 *     UnaryExpression returns ComparisonGreaterEqual
	 *     Projection returns ComparisonGreaterEqual
	 *     Projection.Projection_1_0 returns ComparisonGreaterEqual
	 *     AtomicExpression returns ComparisonGreaterEqual
	 *
	 * Constraint:
	 *     (left=Comparison_ComparisonGreaterEqual_1_0_5_0 right=Addition)
	 */
	protected void sequence_Comparison(ISerializationContext context, ComparisonGreaterEqual semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonGreaterEqual_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonGreaterEqual_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonGreaterEqual_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonGreaterEqual_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getComparisonAccess().getComparisonGreaterEqualLeftAction_1_0_5_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getComparisonAccess().getRightAdditionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ComparisonLesser
	 *     QuantifiedExpression returns ComparisonLesser
	 *     Conditional returns ComparisonLesser
	 *     Conditional.Conditional_1_1 returns ComparisonLesser
	 *     Disjunction returns ComparisonLesser
	 *     Disjunction.Disjunction_1_0 returns ComparisonLesser
	 *     Implication returns ComparisonLesser
	 *     Implication.Implication_1_0 returns ComparisonLesser
	 *     Conjunction returns ComparisonLesser
	 *     Conjunction.Conjunction_1_0 returns ComparisonLesser
	 *     Comparison returns ComparisonLesser
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ComparisonLesser
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ComparisonLesser
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ComparisonLesser
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ComparisonLesser
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ComparisonLesser
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ComparisonLesser
	 *     Addition returns ComparisonLesser
	 *     Addition.Addition_1_0 returns ComparisonLesser
	 *     Substraction returns ComparisonLesser
	 *     Substraction.Substraction_1_0 returns ComparisonLesser
	 *     Multiplication returns ComparisonLesser
	 *     Multiplication.Multiplication_1_0 returns ComparisonLesser
	 *     Division returns ComparisonLesser
	 *     Division.Division_1_0 returns ComparisonLesser
	 *     Modulo returns ComparisonLesser
	 *     Modulo.Modulo_1_0 returns ComparisonLesser
	 *     UnaryExpression returns ComparisonLesser
	 *     Projection returns ComparisonLesser
	 *     Projection.Projection_1_0 returns ComparisonLesser
	 *     AtomicExpression returns ComparisonLesser
	 *
	 * Constraint:
	 *     (left=Comparison_ComparisonLesser_1_0_2_0 right=Addition)
	 */
	protected void sequence_Comparison(ISerializationContext context, ComparisonLesser semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonLesser_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonLesser_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonLesser_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonLesser_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getComparisonAccess().getComparisonLesserLeftAction_1_0_2_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getComparisonAccess().getRightAdditionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ComparisonLesserEqual
	 *     QuantifiedExpression returns ComparisonLesserEqual
	 *     Conditional returns ComparisonLesserEqual
	 *     Conditional.Conditional_1_1 returns ComparisonLesserEqual
	 *     Disjunction returns ComparisonLesserEqual
	 *     Disjunction.Disjunction_1_0 returns ComparisonLesserEqual
	 *     Implication returns ComparisonLesserEqual
	 *     Implication.Implication_1_0 returns ComparisonLesserEqual
	 *     Conjunction returns ComparisonLesserEqual
	 *     Conjunction.Conjunction_1_0 returns ComparisonLesserEqual
	 *     Comparison returns ComparisonLesserEqual
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ComparisonLesserEqual
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ComparisonLesserEqual
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ComparisonLesserEqual
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ComparisonLesserEqual
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ComparisonLesserEqual
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ComparisonLesserEqual
	 *     Addition returns ComparisonLesserEqual
	 *     Addition.Addition_1_0 returns ComparisonLesserEqual
	 *     Substraction returns ComparisonLesserEqual
	 *     Substraction.Substraction_1_0 returns ComparisonLesserEqual
	 *     Multiplication returns ComparisonLesserEqual
	 *     Multiplication.Multiplication_1_0 returns ComparisonLesserEqual
	 *     Division returns ComparisonLesserEqual
	 *     Division.Division_1_0 returns ComparisonLesserEqual
	 *     Modulo returns ComparisonLesserEqual
	 *     Modulo.Modulo_1_0 returns ComparisonLesserEqual
	 *     UnaryExpression returns ComparisonLesserEqual
	 *     Projection returns ComparisonLesserEqual
	 *     Projection.Projection_1_0 returns ComparisonLesserEqual
	 *     AtomicExpression returns ComparisonLesserEqual
	 *
	 * Constraint:
	 *     (left=Comparison_ComparisonLesserEqual_1_0_3_0 right=Addition)
	 */
	protected void sequence_Comparison(ISerializationContext context, ComparisonLesserEqual semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonLesserEqual_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonLesserEqual_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonLesserEqual_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonLesserEqual_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getComparisonAccess().getComparisonLesserEqualLeftAction_1_0_3_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getComparisonAccess().getRightAdditionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ComparisonNotEqual
	 *     QuantifiedExpression returns ComparisonNotEqual
	 *     Conditional returns ComparisonNotEqual
	 *     Conditional.Conditional_1_1 returns ComparisonNotEqual
	 *     Disjunction returns ComparisonNotEqual
	 *     Disjunction.Disjunction_1_0 returns ComparisonNotEqual
	 *     Implication returns ComparisonNotEqual
	 *     Implication.Implication_1_0 returns ComparisonNotEqual
	 *     Conjunction returns ComparisonNotEqual
	 *     Conjunction.Conjunction_1_0 returns ComparisonNotEqual
	 *     Comparison returns ComparisonNotEqual
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ComparisonNotEqual
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ComparisonNotEqual
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ComparisonNotEqual
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ComparisonNotEqual
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ComparisonNotEqual
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ComparisonNotEqual
	 *     Addition returns ComparisonNotEqual
	 *     Addition.Addition_1_0 returns ComparisonNotEqual
	 *     Substraction returns ComparisonNotEqual
	 *     Substraction.Substraction_1_0 returns ComparisonNotEqual
	 *     Multiplication returns ComparisonNotEqual
	 *     Multiplication.Multiplication_1_0 returns ComparisonNotEqual
	 *     Division returns ComparisonNotEqual
	 *     Division.Division_1_0 returns ComparisonNotEqual
	 *     Modulo returns ComparisonNotEqual
	 *     Modulo.Modulo_1_0 returns ComparisonNotEqual
	 *     UnaryExpression returns ComparisonNotEqual
	 *     Projection returns ComparisonNotEqual
	 *     Projection.Projection_1_0 returns ComparisonNotEqual
	 *     AtomicExpression returns ComparisonNotEqual
	 *
	 * Constraint:
	 *     (left=Comparison_ComparisonNotEqual_1_0_1_0 right=Addition)
	 */
	protected void sequence_Comparison(ISerializationContext context, ComparisonNotEqual semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonNotEqual_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonNotEqual_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getComparisonNotEqual_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getComparisonNotEqual_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getComparisonAccess().getComparisonNotEqualLeftAction_1_0_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getComparisonAccess().getRightAdditionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     RootDeclaration returns ComponentDeclaration
	 *     NamedElement returns ComponentDeclaration
	 *     PathDeclarationUse returns ComponentDeclaration
	 *     Declaration returns ComponentDeclaration
	 *     ParameterizedDeclaration returns ComponentDeclaration
	 *     ComponentDeclaration returns ComponentDeclaration
	 *
	 * Constraint:
	 *     (
	 *         name=ID 
	 *         (ports+=PortsDeclaration ports+=PortsDeclaration*)? 
	 *         (parameters+=ParametersDeclaration parameters+=ParametersDeclaration*)? 
	 *         (variables+=VariablesDeclaration variables+=VariablesDeclaration*)? 
	 *         (localPorts+=LocalPortsDeclaration localPorts+=LocalPortsDeclaration*)? 
	 *         (priorities+=PriorityDeclaration priorities+=PriorityDeclaration*)? 
	 *         prelude=StatementSequence? 
	 *         body=Composition
	 *     )
	 */
	protected void sequence_ComponentDeclaration(ISerializationContext context, ComponentDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ComponentInstance returns ComponentInstance
	 *
	 * Constraint:
	 *     (component=[ParameterizedDeclaration|ID] (ports+=Expression ports+=Expression*)? (parameters+=Expression parameters+=Expression*)?)
	 */
	protected void sequence_ComponentInstance(ISerializationContext context, ComponentInstance semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Block returns CompositeBlock
	 *     CompositeBlock returns CompositeBlock
	 *
	 * Constraint:
	 *     (local=PortSet? composition=Composition)
	 */
	protected void sequence_CompositeBlock(ISerializationContext context, CompositeBlock semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Composition returns Composition
	 *
	 * Constraint:
	 *     (global=PortSet? blocks+=Block blocks+=Block*)
	 */
	protected void sequence_Composition(ISerializationContext context, Composition semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns ConditionalStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns ConditionalStatement
	 *     StatementChoice returns ConditionalStatement
	 *     StatementChoice.StatementChoice_1_0 returns ConditionalStatement
	 *     StatementSequence returns ConditionalStatement
	 *     StatementSequence.StatementSequence_1_0 returns ConditionalStatement
	 *     Statement returns ConditionalStatement
	 *     ConditionalStatement returns ConditionalStatement
	 *
	 * Constraint:
	 *     (condition=Expression then=StatementSequence elseif+=ExtendedConditionalStatement* else=StatementSequence?)
	 */
	protected void sequence_ConditionalStatement(ISerializationContext context, ConditionalStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Conditional
	 *     QuantifiedExpression returns Conditional
	 *     Conditional returns Conditional
	 *     Conditional.Conditional_1_1 returns Conditional
	 *     Disjunction returns Conditional
	 *     Disjunction.Disjunction_1_0 returns Conditional
	 *     Implication returns Conditional
	 *     Implication.Implication_1_0 returns Conditional
	 *     Conjunction returns Conditional
	 *     Conjunction.Conjunction_1_0 returns Conditional
	 *     Comparison returns Conditional
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Conditional
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Conditional
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Conditional
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Conditional
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Conditional
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Conditional
	 *     Addition returns Conditional
	 *     Addition.Addition_1_0 returns Conditional
	 *     Substraction returns Conditional
	 *     Substraction.Substraction_1_0 returns Conditional
	 *     Multiplication returns Conditional
	 *     Multiplication.Multiplication_1_0 returns Conditional
	 *     Division returns Conditional
	 *     Division.Division_1_0 returns Conditional
	 *     Modulo returns Conditional
	 *     Modulo.Modulo_1_0 returns Conditional
	 *     UnaryExpression returns Conditional
	 *     Projection returns Conditional
	 *     Projection.Projection_1_0 returns Conditional
	 *     AtomicExpression returns Conditional
	 *
	 * Constraint:
	 *     (condition=Conditional_Conditional_1_1 then=Disjunction else=Disjunction)
	 */
	protected void sequence_Conditional(ISerializationContext context, Conditional semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getConditional_Condition()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getConditional_Condition()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getConditional_Then()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getConditional_Then()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getConditional_Else()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getConditional_Else()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getConditionalAccess().getConditionalConditionAction_1_1(), semanticObject.getCondition());
		feeder.accept(grammarAccess.getConditionalAccess().getThenDisjunctionParserRuleCall_1_2_0(), semanticObject.getThen());
		feeder.accept(grammarAccess.getConditionalAccess().getElseDisjunctionParserRuleCall_1_4_0(), semanticObject.getElse());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Conjunction
	 *     QuantifiedExpression returns Conjunction
	 *     Conditional returns Conjunction
	 *     Conditional.Conditional_1_1 returns Conjunction
	 *     Disjunction returns Conjunction
	 *     Disjunction.Disjunction_1_0 returns Conjunction
	 *     Implication returns Conjunction
	 *     Implication.Implication_1_0 returns Conjunction
	 *     Conjunction returns Conjunction
	 *     Conjunction.Conjunction_1_0 returns Conjunction
	 *     Comparison returns Conjunction
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Conjunction
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Conjunction
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Conjunction
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Conjunction
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Conjunction
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Conjunction
	 *     Addition returns Conjunction
	 *     Addition.Addition_1_0 returns Conjunction
	 *     Substraction returns Conjunction
	 *     Substraction.Substraction_1_0 returns Conjunction
	 *     Multiplication returns Conjunction
	 *     Multiplication.Multiplication_1_0 returns Conjunction
	 *     Division returns Conjunction
	 *     Division.Division_1_0 returns Conjunction
	 *     Modulo returns Conjunction
	 *     Modulo.Modulo_1_0 returns Conjunction
	 *     UnaryExpression returns Conjunction
	 *     Projection returns Conjunction
	 *     Projection.Projection_1_0 returns Conjunction
	 *     AtomicExpression returns Conjunction
	 *
	 * Constraint:
	 *     (left=Conjunction_Conjunction_1_0 right=Comparison)
	 */
	protected void sequence_Conjunction(ISerializationContext context, Conjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getConjunction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getConjunction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getConjunction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getConjunction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getConjunctionAccess().getConjunctionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getConjunctionAccess().getRightComparisonParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns ConstantDeclaration
	 *     ConstantDeclarationUse returns ConstantDeclaration
	 *     ExpressionDeclarationUse returns ConstantDeclaration
	 *     BoundDeclarationUse returns ConstantDeclaration
	 *     Declaration returns ConstantDeclaration
	 *     ConstantDeclaration returns ConstantDeclaration
	 *
	 * Constraint:
	 *     (name=ID type=Type value=Expression)
	 */
	protected void sequence_ConstantDeclaration(ISerializationContext context, ConstantDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getConstantDeclaration_Type()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getConstantDeclaration_Type()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getConstantDeclaration_Value()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getConstantDeclaration_Value()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getConstantDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getConstantDeclarationAccess().getTypeTypeParserRuleCall_3_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getConstantDeclarationAccess().getValueExpressionParserRuleCall_5_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns ConstantPattern
	 *     UnlessStatement.UnlessStatement_1_0 returns ConstantPattern
	 *     StatementChoice returns ConstantPattern
	 *     StatementChoice.StatementChoice_1_0 returns ConstantPattern
	 *     StatementSequence returns ConstantPattern
	 *     StatementSequence.StatementSequence_1_0 returns ConstantPattern
	 *     Statement returns ConstantPattern
	 *     PatternStatement returns ConstantPattern
	 *     PatternStatement.AssignStatement_1_0_1 returns ConstantPattern
	 *     PatternStatement.AssignStatement_1_1_1 returns ConstantPattern
	 *     PatternStatement.AssignAnyStatement_1_2_1 returns ConstantPattern
	 *     PatternStatement.AssignAnyStatement_1_3_1 returns ConstantPattern
	 *     PatternStatement.SendStatement_1_4_1 returns ConstantPattern
	 *     PatternStatement.ReceiveStatement_1_5_1 returns ConstantPattern
	 *     Pattern returns ConstantPattern
	 *     ConstantPattern returns ConstantPattern
	 *
	 * Constraint:
	 *     value=LiteralExpression
	 */
	protected void sequence_ConstantPattern(ISerializationContext context, ConstantPattern semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getConstantPattern_Value()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getConstantPattern_Value()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getConstantPatternAccess().getValueLiteralExpressionParserRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns DeadlockFreePattern
	 *     QuantifiedProperty returns DeadlockFreePattern
	 *     PropertyDisjunction returns DeadlockFreePattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns DeadlockFreePattern
	 *     PropertyImplication returns DeadlockFreePattern
	 *     PropertyImplication.PropertyImplication_1_0 returns DeadlockFreePattern
	 *     PropertyConjunction returns DeadlockFreePattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns DeadlockFreePattern
	 *     PropertyNegation returns DeadlockFreePattern
	 *     AtomicProperty returns DeadlockFreePattern
	 *     PatternProperty returns DeadlockFreePattern
	 *     DeadlockFreePattern returns DeadlockFreePattern
	 *
	 * Constraint:
	 *     {DeadlockFreePattern}
	 */
	protected void sequence_DeadlockFreePattern(ISerializationContext context, DeadlockFreePattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     LowerBound returns DecimalLowerBound
	 *     DecimalLowerBound returns DecimalLowerBound
	 *
	 * Constraint:
	 *     ((left?='[' | right?=']') value=FLT)
	 */
	protected void sequence_DecimalLowerBound(ISerializationContext context, DecimalLowerBound semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UpperBound returns DecimalUpperBound
	 *     DecimalUpperBound returns DecimalUpperBound
	 *
	 * Constraint:
	 *     (value=FLT (left?='[' | right?=']'))
	 */
	protected void sequence_DecimalUpperBound(ISerializationContext context, DecimalUpperBound semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Disjunction
	 *     QuantifiedExpression returns Disjunction
	 *     Conditional returns Disjunction
	 *     Conditional.Conditional_1_1 returns Disjunction
	 *     Disjunction returns Disjunction
	 *     Disjunction.Disjunction_1_0 returns Disjunction
	 *     Implication returns Disjunction
	 *     Implication.Implication_1_0 returns Disjunction
	 *     Conjunction returns Disjunction
	 *     Conjunction.Conjunction_1_0 returns Disjunction
	 *     Comparison returns Disjunction
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Disjunction
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Disjunction
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Disjunction
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Disjunction
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Disjunction
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Disjunction
	 *     Addition returns Disjunction
	 *     Addition.Addition_1_0 returns Disjunction
	 *     Substraction returns Disjunction
	 *     Substraction.Substraction_1_0 returns Disjunction
	 *     Multiplication returns Disjunction
	 *     Multiplication.Multiplication_1_0 returns Disjunction
	 *     Division returns Disjunction
	 *     Division.Division_1_0 returns Disjunction
	 *     Modulo returns Disjunction
	 *     Modulo.Modulo_1_0 returns Disjunction
	 *     UnaryExpression returns Disjunction
	 *     Projection returns Disjunction
	 *     Projection.Projection_1_0 returns Disjunction
	 *     AtomicExpression returns Disjunction
	 *
	 * Constraint:
	 *     (left=Disjunction_Disjunction_1_0 right=Implication)
	 */
	protected void sequence_Disjunction(ISerializationContext context, Disjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getDisjunction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getDisjunction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getDisjunction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getDisjunction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDisjunctionAccess().getDisjunctionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDisjunctionAccess().getRightImplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Division
	 *     QuantifiedExpression returns Division
	 *     Conditional returns Division
	 *     Conditional.Conditional_1_1 returns Division
	 *     Disjunction returns Division
	 *     Disjunction.Disjunction_1_0 returns Division
	 *     Implication returns Division
	 *     Implication.Implication_1_0 returns Division
	 *     Conjunction returns Division
	 *     Conjunction.Conjunction_1_0 returns Division
	 *     Comparison returns Division
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Division
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Division
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Division
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Division
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Division
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Division
	 *     Addition returns Division
	 *     Addition.Addition_1_0 returns Division
	 *     Substraction returns Division
	 *     Substraction.Substraction_1_0 returns Division
	 *     Multiplication returns Division
	 *     Multiplication.Multiplication_1_0 returns Division
	 *     Division returns Division
	 *     Division.Division_1_0 returns Division
	 *     Modulo returns Division
	 *     Modulo.Modulo_1_0 returns Division
	 *     UnaryExpression returns Division
	 *     Projection returns Division
	 *     Projection.Projection_1_0 returns Division
	 *     AtomicExpression returns Division
	 *
	 * Constraint:
	 *     (left=Division_Division_1_0 right=Modulo)
	 */
	protected void sequence_Division(ISerializationContext context, Division semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getDivision_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getDivision_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getDivision_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getDivision_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDivisionAccess().getDivisionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDivisionAccess().getRightModuloParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns EnqueueExpression
	 *     QuantifiedExpression returns EnqueueExpression
	 *     Conditional returns EnqueueExpression
	 *     Conditional.Conditional_1_1 returns EnqueueExpression
	 *     Disjunction returns EnqueueExpression
	 *     Disjunction.Disjunction_1_0 returns EnqueueExpression
	 *     Implication returns EnqueueExpression
	 *     Implication.Implication_1_0 returns EnqueueExpression
	 *     Conjunction returns EnqueueExpression
	 *     Conjunction.Conjunction_1_0 returns EnqueueExpression
	 *     Comparison returns EnqueueExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns EnqueueExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns EnqueueExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns EnqueueExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns EnqueueExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns EnqueueExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns EnqueueExpression
	 *     Addition returns EnqueueExpression
	 *     Addition.Addition_1_0 returns EnqueueExpression
	 *     Substraction returns EnqueueExpression
	 *     Substraction.Substraction_1_0 returns EnqueueExpression
	 *     Multiplication returns EnqueueExpression
	 *     Multiplication.Multiplication_1_0 returns EnqueueExpression
	 *     Division returns EnqueueExpression
	 *     Division.Division_1_0 returns EnqueueExpression
	 *     Modulo returns EnqueueExpression
	 *     Modulo.Modulo_1_0 returns EnqueueExpression
	 *     UnaryExpression returns EnqueueExpression
	 *     Projection returns EnqueueExpression
	 *     Projection.Projection_1_0 returns EnqueueExpression
	 *     AtomicExpression returns EnqueueExpression
	 *     EnqueueExpression returns EnqueueExpression
	 *
	 * Constraint:
	 *     (element=Expression queue=Expression)
	 */
	protected void sequence_EnqueueExpression(ISerializationContext context, EnqueueExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getEnqueueExpression_Element()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getEnqueueExpression_Element()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getEnqueueExpression_Queue()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getEnqueueExpression_Queue()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getEnqueueExpressionAccess().getElementExpressionParserRuleCall_2_0(), semanticObject.getElement());
		feeder.accept(grammarAccess.getEnqueueExpressionAccess().getQueueExpressionParserRuleCall_4_0(), semanticObject.getQueue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SequencePattern.LeadsToPattern_1_0_1 returns EnterStateEvent
	 *     SequencePattern.PrecedesPattern_1_1_1 returns EnterStateEvent
	 *     LTLProperty returns EnterStateEvent
	 *     LTLQuantified returns EnterStateEvent
	 *     LTLDisjunction returns EnterStateEvent
	 *     LTLDisjunction.LTLDisjunction_1_0 returns EnterStateEvent
	 *     LTLImplication returns EnterStateEvent
	 *     LTLImplication.LTLImplication_1_0 returns EnterStateEvent
	 *     LTLConjunction returns EnterStateEvent
	 *     LTLConjunction.LTLConjunction_1_0 returns EnterStateEvent
	 *     LTLBinary returns EnterStateEvent
	 *     LTLBinary.LTLUntil_1_0_0 returns EnterStateEvent
	 *     LTLBinary.LTLRelease_1_1_0 returns EnterStateEvent
	 *     LTLUnary returns EnterStateEvent
	 *     AtomicLTL returns EnterStateEvent
	 *     StateEvent returns EnterStateEvent
	 *     EnterStateEvent returns EnterStateEvent
	 *     Observable returns EnterStateEvent
	 *     ObservableDisjunction returns EnterStateEvent
	 *     ObservableDisjunction.ObservableDisjunction_1_0 returns EnterStateEvent
	 *     ObservableImplication returns EnterStateEvent
	 *     ObservableImplication.ObservableImplication_1_0 returns EnterStateEvent
	 *     ObservableConjunction returns EnterStateEvent
	 *     ObservableConjunction.ObservableConjunction_1_0 returns EnterStateEvent
	 *     ObservableNegation returns EnterStateEvent
	 *     AtomicObservable returns EnterStateEvent
	 *     ObservableEvent returns EnterStateEvent
	 *
	 * Constraint:
	 *     subject=AtomicObservable
	 */
	protected void sequence_EnterStateEvent(ISerializationContext context, EnterStateEvent semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getStateEvent_Subject()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getStateEvent_Subject()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getEnterStateEventAccess().getSubjectAtomicObservableParserRuleCall_1_0(), semanticObject.getSubject());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Subject returns EventSubject
	 *     EventSubject returns EventSubject
	 *
	 * Constraint:
	 *     event=ID
	 */
	protected void sequence_EventSubject(ISerializationContext context, EventSubject semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getEventSubject_Event()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getEventSubject_Event()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getEventSubjectAccess().getEventIDTerminalRuleCall_1_0(), semanticObject.getEvent());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ExtendedConditionalStatement returns ExtendedConditionalStatement
	 *
	 * Constraint:
	 *     (condition=Expression then=StatementSequence)
	 */
	protected void sequence_ExtendedConditionalStatement(ISerializationContext context, ExtendedConditionalStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getExtendedConditionalStatement_Condition()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getExtendedConditionalStatement_Condition()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getExtendedConditionalStatement_Then()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getExtendedConditionalStatement_Then()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getExtendedConditionalStatementAccess().getConditionExpressionParserRuleCall_1_0(), semanticObject.getCondition());
		feeder.accept(grammarAccess.getExtendedConditionalStatementAccess().getThenStatementSequenceParserRuleCall_3_0(), semanticObject.getThen());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FieldExpression returns FieldExpression
	 *
	 * Constraint:
	 *     (field=[RecordFieldDeclarationUse|ID] value=Expression)
	 */
	protected void sequence_FieldExpression(ISerializationContext context, FieldExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getFieldExpression_Field()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getFieldExpression_Field()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getFieldExpression_Value()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getFieldExpression_Value()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFieldExpressionAccess().getFieldRecordFieldDeclarationUseIDTerminalRuleCall_0_0_1(), semanticObject.getField());
		feeder.accept(grammarAccess.getFieldExpressionAccess().getValueExpressionParserRuleCall_2_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns ForeachStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns ForeachStatement
	 *     StatementChoice returns ForeachStatement
	 *     StatementChoice.StatementChoice_1_0 returns ForeachStatement
	 *     StatementSequence returns ForeachStatement
	 *     StatementSequence.StatementSequence_1_0 returns ForeachStatement
	 *     Statement returns ForeachStatement
	 *     ForeachStatement returns ForeachStatement
	 *
	 * Constraint:
	 *     (variable=VariableDeclaration body=StatementSequence)
	 */
	protected void sequence_ForeachStatement(ISerializationContext context, ForeachStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getForeachStatement_Variable()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getForeachStatement_Variable()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getForeachStatement_Body()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getForeachStatement_Body()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getForeachStatementAccess().getVariableVariableDeclarationParserRuleCall_1_0(), semanticObject.getVariable());
		feeder.accept(grammarAccess.getForeachStatementAccess().getBodyStatementSequenceParserRuleCall_3_0(), semanticObject.getBody());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns FunctionDeclaration
	 *     ExpressionDeclarationUse returns FunctionDeclaration
	 *     Declaration returns FunctionDeclaration
	 *     ParameterizedDeclaration returns FunctionDeclaration
	 *     FunctionDeclaration returns FunctionDeclaration
	 *
	 * Constraint:
	 *     (
	 *         name=ID 
	 *         (parameters+=ParametersDeclaration parameters+=ParametersDeclaration*)? 
	 *         type=Type 
	 *         (variables+=VariablesDeclaration variables+=VariablesDeclaration*)? 
	 *         statement=Statement
	 *     )
	 */
	protected void sequence_FunctionDeclaration(ISerializationContext context, FunctionDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ArrayAccessExpression
	 *     QuantifiedExpression returns ArrayAccessExpression
	 *     Conditional returns ArrayAccessExpression
	 *     Conditional.Conditional_1_1 returns ArrayAccessExpression
	 *     Disjunction returns ArrayAccessExpression
	 *     Disjunction.Disjunction_1_0 returns ArrayAccessExpression
	 *     Implication returns ArrayAccessExpression
	 *     Implication.Implication_1_0 returns ArrayAccessExpression
	 *     Conjunction returns ArrayAccessExpression
	 *     Conjunction.Conjunction_1_0 returns ArrayAccessExpression
	 *     Comparison returns ArrayAccessExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ArrayAccessExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ArrayAccessExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ArrayAccessExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ArrayAccessExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ArrayAccessExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ArrayAccessExpression
	 *     Addition returns ArrayAccessExpression
	 *     Addition.Addition_1_0 returns ArrayAccessExpression
	 *     Substraction returns ArrayAccessExpression
	 *     Substraction.Substraction_1_0 returns ArrayAccessExpression
	 *     Multiplication returns ArrayAccessExpression
	 *     Multiplication.Multiplication_1_0 returns ArrayAccessExpression
	 *     Division returns ArrayAccessExpression
	 *     Division.Division_1_0 returns ArrayAccessExpression
	 *     Modulo returns ArrayAccessExpression
	 *     Modulo.Modulo_1_0 returns ArrayAccessExpression
	 *     UnaryExpression returns ArrayAccessExpression
	 *     Projection returns ArrayAccessExpression
	 *     Projection.Projection_1_0 returns ArrayAccessExpression
	 *     ValueExpression returns ArrayAccessExpression
	 *     AtomicExpression returns ArrayAccessExpression
	 *     IdentifierExpression returns ArrayAccessExpression
	 *     IdentifierExpression.ArrayAccessExpression_1_1_0_1 returns ArrayAccessExpression
	 *     IdentifierExpression.RecordAccessExpression_1_1_1_1 returns ArrayAccessExpression
	 *
	 * Constraint:
	 *     (child=IdentifierExpression_ArrayAccessExpression_1_1_0_1 indexes+=Expression indexes+=Expression*)
	 */
	protected void sequence_IdentifierExpression(ISerializationContext context, ArrayAccessExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ConstructionExpression
	 *     QuantifiedExpression returns ConstructionExpression
	 *     Conditional returns ConstructionExpression
	 *     Conditional.Conditional_1_1 returns ConstructionExpression
	 *     Disjunction returns ConstructionExpression
	 *     Disjunction.Disjunction_1_0 returns ConstructionExpression
	 *     Implication returns ConstructionExpression
	 *     Implication.Implication_1_0 returns ConstructionExpression
	 *     Conjunction returns ConstructionExpression
	 *     Conjunction.Conjunction_1_0 returns ConstructionExpression
	 *     Comparison returns ConstructionExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ConstructionExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ConstructionExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ConstructionExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ConstructionExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ConstructionExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ConstructionExpression
	 *     Addition returns ConstructionExpression
	 *     Addition.Addition_1_0 returns ConstructionExpression
	 *     Substraction returns ConstructionExpression
	 *     Substraction.Substraction_1_0 returns ConstructionExpression
	 *     Multiplication returns ConstructionExpression
	 *     Multiplication.Multiplication_1_0 returns ConstructionExpression
	 *     Division returns ConstructionExpression
	 *     Division.Division_1_0 returns ConstructionExpression
	 *     Modulo returns ConstructionExpression
	 *     Modulo.Modulo_1_0 returns ConstructionExpression
	 *     UnaryExpression returns ConstructionExpression
	 *     Projection returns ConstructionExpression
	 *     Projection.Projection_1_0 returns ConstructionExpression
	 *     ValueExpression returns ConstructionExpression
	 *     AtomicExpression returns ConstructionExpression
	 *     IdentifierExpression returns ConstructionExpression
	 *
	 * Constraint:
	 *     (declaration=[ExpressionDeclarationUse|ID] (parameters+=Expression parameters+=Expression*)?)
	 */
	protected void sequence_IdentifierExpression(ISerializationContext context, ConstructionExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns IdentifierExpression
	 *     QuantifiedExpression returns IdentifierExpression
	 *     Conditional returns IdentifierExpression
	 *     Conditional.Conditional_1_1 returns IdentifierExpression
	 *     Disjunction returns IdentifierExpression
	 *     Disjunction.Disjunction_1_0 returns IdentifierExpression
	 *     Implication returns IdentifierExpression
	 *     Implication.Implication_1_0 returns IdentifierExpression
	 *     Conjunction returns IdentifierExpression
	 *     Conjunction.Conjunction_1_0 returns IdentifierExpression
	 *     Comparison returns IdentifierExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns IdentifierExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns IdentifierExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns IdentifierExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns IdentifierExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns IdentifierExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns IdentifierExpression
	 *     Addition returns IdentifierExpression
	 *     Addition.Addition_1_0 returns IdentifierExpression
	 *     Substraction returns IdentifierExpression
	 *     Substraction.Substraction_1_0 returns IdentifierExpression
	 *     Multiplication returns IdentifierExpression
	 *     Multiplication.Multiplication_1_0 returns IdentifierExpression
	 *     Division returns IdentifierExpression
	 *     Division.Division_1_0 returns IdentifierExpression
	 *     Modulo returns IdentifierExpression
	 *     Modulo.Modulo_1_0 returns IdentifierExpression
	 *     UnaryExpression returns IdentifierExpression
	 *     Projection returns IdentifierExpression
	 *     Projection.Projection_1_0 returns IdentifierExpression
	 *     ValueExpression returns IdentifierExpression
	 *     AtomicExpression returns IdentifierExpression
	 *     IdentifierExpression returns IdentifierExpression
	 *     IdentifierExpression.ArrayAccessExpression_1_1_0_1 returns IdentifierExpression
	 *     IdentifierExpression.RecordAccessExpression_1_1_1_1 returns IdentifierExpression
	 *
	 * Constraint:
	 *     declaration=[ExpressionDeclarationUse|ID]
	 */
	protected void sequence_IdentifierExpression(ISerializationContext context, IdentifierExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getIdentifierExpression_Declaration()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getIdentifierExpression_Declaration()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseIDTerminalRuleCall_1_0_0_1(), semanticObject.getDeclaration());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns RecordAccessExpression
	 *     QuantifiedExpression returns RecordAccessExpression
	 *     Conditional returns RecordAccessExpression
	 *     Conditional.Conditional_1_1 returns RecordAccessExpression
	 *     Disjunction returns RecordAccessExpression
	 *     Disjunction.Disjunction_1_0 returns RecordAccessExpression
	 *     Implication returns RecordAccessExpression
	 *     Implication.Implication_1_0 returns RecordAccessExpression
	 *     Conjunction returns RecordAccessExpression
	 *     Conjunction.Conjunction_1_0 returns RecordAccessExpression
	 *     Comparison returns RecordAccessExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns RecordAccessExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns RecordAccessExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns RecordAccessExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns RecordAccessExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns RecordAccessExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns RecordAccessExpression
	 *     Addition returns RecordAccessExpression
	 *     Addition.Addition_1_0 returns RecordAccessExpression
	 *     Substraction returns RecordAccessExpression
	 *     Substraction.Substraction_1_0 returns RecordAccessExpression
	 *     Multiplication returns RecordAccessExpression
	 *     Multiplication.Multiplication_1_0 returns RecordAccessExpression
	 *     Division returns RecordAccessExpression
	 *     Division.Division_1_0 returns RecordAccessExpression
	 *     Modulo returns RecordAccessExpression
	 *     Modulo.Modulo_1_0 returns RecordAccessExpression
	 *     UnaryExpression returns RecordAccessExpression
	 *     Projection returns RecordAccessExpression
	 *     Projection.Projection_1_0 returns RecordAccessExpression
	 *     ValueExpression returns RecordAccessExpression
	 *     AtomicExpression returns RecordAccessExpression
	 *     IdentifierExpression returns RecordAccessExpression
	 *     IdentifierExpression.ArrayAccessExpression_1_1_0_1 returns RecordAccessExpression
	 *     IdentifierExpression.RecordAccessExpression_1_1_1_1 returns RecordAccessExpression
	 *
	 * Constraint:
	 *     (child=IdentifierExpression_RecordAccessExpression_1_1_1_1 field=[RecordFieldDeclaration|ID])
	 */
	protected void sequence_IdentifierExpression(ISerializationContext context, RecordAccessExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getRecordAccessExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getRecordAccessExpression_Child()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getRecordAccessExpression_Field()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getRecordAccessExpression_Field()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getIdentifierExpressionAccess().getRecordAccessExpressionChildAction_1_1_1_1(), semanticObject.getChild());
		feeder.accept(grammarAccess.getIdentifierExpressionAccess().getFieldRecordFieldDeclarationIDTerminalRuleCall_1_1_1_2_0_1(), semanticObject.getField());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns ArrayAccessPattern
	 *     UnlessStatement.UnlessStatement_1_0 returns ArrayAccessPattern
	 *     StatementChoice returns ArrayAccessPattern
	 *     StatementChoice.StatementChoice_1_0 returns ArrayAccessPattern
	 *     StatementSequence returns ArrayAccessPattern
	 *     StatementSequence.StatementSequence_1_0 returns ArrayAccessPattern
	 *     Statement returns ArrayAccessPattern
	 *     PatternStatement returns ArrayAccessPattern
	 *     PatternStatement.AssignStatement_1_0_1 returns ArrayAccessPattern
	 *     PatternStatement.AssignStatement_1_1_1 returns ArrayAccessPattern
	 *     PatternStatement.AssignAnyStatement_1_2_1 returns ArrayAccessPattern
	 *     PatternStatement.AssignAnyStatement_1_3_1 returns ArrayAccessPattern
	 *     PatternStatement.SendStatement_1_4_1 returns ArrayAccessPattern
	 *     PatternStatement.ReceiveStatement_1_5_1 returns ArrayAccessPattern
	 *     Pattern returns ArrayAccessPattern
	 *     IdentifierPattern returns ArrayAccessPattern
	 *     IdentifierPattern.ArrayAccessPattern_1_1_0_1 returns ArrayAccessPattern
	 *     IdentifierPattern.RecordAccessPattern_1_1_1_1 returns ArrayAccessPattern
	 *
	 * Constraint:
	 *     (source=IdentifierPattern_ArrayAccessPattern_1_1_0_1 index=Expression)
	 */
	protected void sequence_IdentifierPattern(ISerializationContext context, ArrayAccessPattern semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getArrayAccessPattern_Source()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getArrayAccessPattern_Source()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getArrayAccessPattern_Index()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getArrayAccessPattern_Index()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getIdentifierPatternAccess().getArrayAccessPatternSourceAction_1_1_0_1(), semanticObject.getSource());
		feeder.accept(grammarAccess.getIdentifierPatternAccess().getIndexExpressionParserRuleCall_1_1_0_2_0(), semanticObject.getIndex());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns ConstructorPattern
	 *     UnlessStatement.UnlessStatement_1_0 returns ConstructorPattern
	 *     StatementChoice returns ConstructorPattern
	 *     StatementChoice.StatementChoice_1_0 returns ConstructorPattern
	 *     StatementSequence returns ConstructorPattern
	 *     StatementSequence.StatementSequence_1_0 returns ConstructorPattern
	 *     Statement returns ConstructorPattern
	 *     PatternStatement returns ConstructorPattern
	 *     PatternStatement.AssignStatement_1_0_1 returns ConstructorPattern
	 *     PatternStatement.AssignStatement_1_1_1 returns ConstructorPattern
	 *     PatternStatement.AssignAnyStatement_1_2_1 returns ConstructorPattern
	 *     PatternStatement.AssignAnyStatement_1_3_1 returns ConstructorPattern
	 *     PatternStatement.SendStatement_1_4_1 returns ConstructorPattern
	 *     PatternStatement.ReceiveStatement_1_5_1 returns ConstructorPattern
	 *     Pattern returns ConstructorPattern
	 *     IdentifierPattern returns ConstructorPattern
	 *
	 * Constraint:
	 *     (declaration=[PatternDeclarationUse|ID] (parameters+=Pattern parameters+=Pattern*)?)
	 */
	protected void sequence_IdentifierPattern(ISerializationContext context, ConstructorPattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns IdentifierPattern
	 *     UnlessStatement.UnlessStatement_1_0 returns IdentifierPattern
	 *     StatementChoice returns IdentifierPattern
	 *     StatementChoice.StatementChoice_1_0 returns IdentifierPattern
	 *     StatementSequence returns IdentifierPattern
	 *     StatementSequence.StatementSequence_1_0 returns IdentifierPattern
	 *     Statement returns IdentifierPattern
	 *     PatternStatement returns IdentifierPattern
	 *     PatternStatement.AssignStatement_1_0_1 returns IdentifierPattern
	 *     PatternStatement.AssignStatement_1_1_1 returns IdentifierPattern
	 *     PatternStatement.AssignAnyStatement_1_2_1 returns IdentifierPattern
	 *     PatternStatement.AssignAnyStatement_1_3_1 returns IdentifierPattern
	 *     PatternStatement.SendStatement_1_4_1 returns IdentifierPattern
	 *     PatternStatement.ReceiveStatement_1_5_1 returns IdentifierPattern
	 *     Pattern returns IdentifierPattern
	 *     IdentifierPattern returns IdentifierPattern
	 *     IdentifierPattern.ArrayAccessPattern_1_1_0_1 returns IdentifierPattern
	 *     IdentifierPattern.RecordAccessPattern_1_1_1_1 returns IdentifierPattern
	 *
	 * Constraint:
	 *     declaration=[PatternDeclarationUse|ID]
	 */
	protected void sequence_IdentifierPattern(ISerializationContext context, IdentifierPattern semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getIdentifierPattern_Declaration()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getIdentifierPattern_Declaration()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseIDTerminalRuleCall_1_0_0_1(), semanticObject.getDeclaration());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns RecordAccessPattern
	 *     UnlessStatement.UnlessStatement_1_0 returns RecordAccessPattern
	 *     StatementChoice returns RecordAccessPattern
	 *     StatementChoice.StatementChoice_1_0 returns RecordAccessPattern
	 *     StatementSequence returns RecordAccessPattern
	 *     StatementSequence.StatementSequence_1_0 returns RecordAccessPattern
	 *     Statement returns RecordAccessPattern
	 *     PatternStatement returns RecordAccessPattern
	 *     PatternStatement.AssignStatement_1_0_1 returns RecordAccessPattern
	 *     PatternStatement.AssignStatement_1_1_1 returns RecordAccessPattern
	 *     PatternStatement.AssignAnyStatement_1_2_1 returns RecordAccessPattern
	 *     PatternStatement.AssignAnyStatement_1_3_1 returns RecordAccessPattern
	 *     PatternStatement.SendStatement_1_4_1 returns RecordAccessPattern
	 *     PatternStatement.ReceiveStatement_1_5_1 returns RecordAccessPattern
	 *     Pattern returns RecordAccessPattern
	 *     IdentifierPattern returns RecordAccessPattern
	 *     IdentifierPattern.ArrayAccessPattern_1_1_0_1 returns RecordAccessPattern
	 *     IdentifierPattern.RecordAccessPattern_1_1_1_1 returns RecordAccessPattern
	 *
	 * Constraint:
	 *     (source=IdentifierPattern_RecordAccessPattern_1_1_1_1 field=[RecordFieldDeclaration|ID])
	 */
	protected void sequence_IdentifierPattern(ISerializationContext context, RecordAccessPattern semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getRecordAccessPattern_Source()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getRecordAccessPattern_Source()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getRecordAccessPattern_Field()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getRecordAccessPattern_Field()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getIdentifierPatternAccess().getRecordAccessPatternSourceAction_1_1_1_1(), semanticObject.getSource());
		feeder.accept(grammarAccess.getIdentifierPatternAccess().getFieldRecordFieldDeclarationIDTerminalRuleCall_1_1_1_2_0_1(), semanticObject.getField());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Implication
	 *     QuantifiedExpression returns Implication
	 *     Conditional returns Implication
	 *     Conditional.Conditional_1_1 returns Implication
	 *     Disjunction returns Implication
	 *     Disjunction.Disjunction_1_0 returns Implication
	 *     Implication returns Implication
	 *     Implication.Implication_1_0 returns Implication
	 *     Conjunction returns Implication
	 *     Conjunction.Conjunction_1_0 returns Implication
	 *     Comparison returns Implication
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Implication
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Implication
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Implication
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Implication
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Implication
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Implication
	 *     Addition returns Implication
	 *     Addition.Addition_1_0 returns Implication
	 *     Substraction returns Implication
	 *     Substraction.Substraction_1_0 returns Implication
	 *     Multiplication returns Implication
	 *     Multiplication.Multiplication_1_0 returns Implication
	 *     Division returns Implication
	 *     Division.Division_1_0 returns Implication
	 *     Modulo returns Implication
	 *     Modulo.Modulo_1_0 returns Implication
	 *     UnaryExpression returns Implication
	 *     Projection returns Implication
	 *     Projection.Projection_1_0 returns Implication
	 *     AtomicExpression returns Implication
	 *
	 * Constraint:
	 *     (left=Implication_Implication_1_0 right=Implication)
	 */
	protected void sequence_Implication(ISerializationContext context, Implication semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getImplication_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getImplication_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getImplication_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getImplication_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getImplicationAccess().getImplicationLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getImplicationAccess().getRightImplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ImportDeclaration returns ImportDeclaration
	 *
	 * Constraint:
	 *     importURI=STRING
	 */
	protected void sequence_ImportDeclaration(ISerializationContext context, ImportDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getImportDeclaration_ImportURI()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getImportDeclaration_ImportURI()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getImportDeclarationAccess().getImportURISTRINGTerminalRuleCall_1_0(), semanticObject.getImportURI());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UpperBound returns InfiniteUpperBound
	 *     InfiniteUpperBound returns InfiniteUpperBound
	 *
	 * Constraint:
	 *     {InfiniteUpperBound}
	 */
	protected void sequence_InfiniteUpperBound(ISerializationContext context, InfiniteUpperBound semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Property returns InfinitelyOftenPattern
	 *     QuantifiedProperty returns InfinitelyOftenPattern
	 *     PropertyDisjunction returns InfinitelyOftenPattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns InfinitelyOftenPattern
	 *     PropertyImplication returns InfinitelyOftenPattern
	 *     PropertyImplication.PropertyImplication_1_0 returns InfinitelyOftenPattern
	 *     PropertyConjunction returns InfinitelyOftenPattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns InfinitelyOftenPattern
	 *     PropertyNegation returns InfinitelyOftenPattern
	 *     AtomicProperty returns InfinitelyOftenPattern
	 *     PatternProperty returns InfinitelyOftenPattern
	 *     InfinitelyOftenPattern returns InfinitelyOftenPattern
	 *
	 * Constraint:
	 *     subject=AtomicObservable
	 */
	protected void sequence_InfinitelyOftenPattern(ISerializationContext context, InfinitelyOftenPattern semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getInfinitelyOftenPattern_Subject()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getInfinitelyOftenPattern_Subject()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getInfinitelyOftenPatternAccess().getSubjectAtomicObservableParserRuleCall_1_0(), semanticObject.getSubject());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     PathDeclarationUse returns InstanceDeclaration
	 *     Block returns InstanceDeclaration
	 *     InstanceDeclaration returns InstanceDeclaration
	 *
	 * Constraint:
	 *     (local=PortSet? instance=ComponentInstance)
	 */
	protected void sequence_InstanceDeclaration(ISerializationContext context, InstanceDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns IntegerPattern
	 *     UnlessStatement.UnlessStatement_1_0 returns IntegerPattern
	 *     StatementChoice returns IntegerPattern
	 *     StatementChoice.StatementChoice_1_0 returns IntegerPattern
	 *     StatementSequence returns IntegerPattern
	 *     StatementSequence.StatementSequence_1_0 returns IntegerPattern
	 *     Statement returns IntegerPattern
	 *     PatternStatement returns IntegerPattern
	 *     PatternStatement.AssignStatement_1_0_1 returns IntegerPattern
	 *     PatternStatement.AssignStatement_1_1_1 returns IntegerPattern
	 *     PatternStatement.AssignAnyStatement_1_2_1 returns IntegerPattern
	 *     PatternStatement.AssignAnyStatement_1_3_1 returns IntegerPattern
	 *     PatternStatement.SendStatement_1_4_1 returns IntegerPattern
	 *     PatternStatement.ReceiveStatement_1_5_1 returns IntegerPattern
	 *     Pattern returns IntegerPattern
	 *     IntegerPattern returns IntegerPattern
	 *
	 * Constraint:
	 *     (negative?='-'? value=INT)
	 */
	protected void sequence_IntegerPattern(ISerializationContext context, IntegerPattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLRelease
	 *     LTLQuantified returns LTLRelease
	 *     LTLDisjunction returns LTLRelease
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLRelease
	 *     LTLImplication returns LTLRelease
	 *     LTLImplication.LTLImplication_1_0 returns LTLRelease
	 *     LTLConjunction returns LTLRelease
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLRelease
	 *     LTLBinary returns LTLRelease
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLRelease
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLRelease
	 *     LTLUnary returns LTLRelease
	 *     AtomicLTL returns LTLRelease
	 *
	 * Constraint:
	 *     (left=LTLBinary_LTLRelease_1_1_0 right=LTLUnary)
	 */
	protected void sequence_LTLBinary(ISerializationContext context, LTLRelease semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLRelease_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLRelease_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLRelease_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLRelease_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLBinaryAccess().getLTLReleaseLeftAction_1_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getLTLBinaryAccess().getRightLTLUnaryParserRuleCall_1_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLUntil
	 *     LTLQuantified returns LTLUntil
	 *     LTLDisjunction returns LTLUntil
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLUntil
	 *     LTLImplication returns LTLUntil
	 *     LTLImplication.LTLImplication_1_0 returns LTLUntil
	 *     LTLConjunction returns LTLUntil
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLUntil
	 *     LTLBinary returns LTLUntil
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLUntil
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLUntil
	 *     LTLUnary returns LTLUntil
	 *     AtomicLTL returns LTLUntil
	 *
	 * Constraint:
	 *     (left=LTLBinary_LTLUntil_1_0_0 right=LTLUnary)
	 */
	protected void sequence_LTLBinary(ISerializationContext context, LTLUntil semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLUntil_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLUntil_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLUntil_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLUntil_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLBinaryAccess().getLTLUntilLeftAction_1_0_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getLTLBinaryAccess().getRightLTLUnaryParserRuleCall_1_0_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLConjunction
	 *     LTLQuantified returns LTLConjunction
	 *     LTLDisjunction returns LTLConjunction
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLConjunction
	 *     LTLImplication returns LTLConjunction
	 *     LTLImplication.LTLImplication_1_0 returns LTLConjunction
	 *     LTLConjunction returns LTLConjunction
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLConjunction
	 *     LTLBinary returns LTLConjunction
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLConjunction
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLConjunction
	 *     LTLUnary returns LTLConjunction
	 *     AtomicLTL returns LTLConjunction
	 *
	 * Constraint:
	 *     (left=LTLConjunction_LTLConjunction_1_0 right=LTLBinary)
	 */
	protected void sequence_LTLConjunction(ISerializationContext context, LTLConjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLConjunction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLConjunction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLConjunction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLConjunction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLConjunctionAccess().getLTLConjunctionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getLTLConjunctionAccess().getRightLTLBinaryParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLDisjunction
	 *     LTLQuantified returns LTLDisjunction
	 *     LTLDisjunction returns LTLDisjunction
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLDisjunction
	 *     LTLImplication returns LTLDisjunction
	 *     LTLImplication.LTLImplication_1_0 returns LTLDisjunction
	 *     LTLConjunction returns LTLDisjunction
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLDisjunction
	 *     LTLBinary returns LTLDisjunction
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLDisjunction
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLDisjunction
	 *     LTLUnary returns LTLDisjunction
	 *     AtomicLTL returns LTLDisjunction
	 *
	 * Constraint:
	 *     (left=LTLDisjunction_LTLDisjunction_1_0 right=LTLImplication)
	 */
	protected void sequence_LTLDisjunction(ISerializationContext context, LTLDisjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLDisjunction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLDisjunction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLDisjunction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLDisjunction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLDisjunctionAccess().getLTLDisjunctionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getLTLDisjunctionAccess().getRightLTLImplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLImplication
	 *     LTLQuantified returns LTLImplication
	 *     LTLDisjunction returns LTLImplication
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLImplication
	 *     LTLImplication returns LTLImplication
	 *     LTLImplication.LTLImplication_1_0 returns LTLImplication
	 *     LTLConjunction returns LTLImplication
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLImplication
	 *     LTLBinary returns LTLImplication
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLImplication
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLImplication
	 *     LTLUnary returns LTLImplication
	 *     AtomicLTL returns LTLImplication
	 *
	 * Constraint:
	 *     (left=LTLImplication_LTLImplication_1_0 right=LTLImplication)
	 */
	protected void sequence_LTLImplication(ISerializationContext context, LTLImplication semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLImplication_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLImplication_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLImplication_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLImplication_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLImplicationAccess().getLTLImplicationLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getLTLImplicationAccess().getRightLTLImplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns LTLPattern
	 *     QuantifiedProperty returns LTLPattern
	 *     PropertyDisjunction returns LTLPattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns LTLPattern
	 *     PropertyImplication returns LTLPattern
	 *     PropertyImplication.PropertyImplication_1_0 returns LTLPattern
	 *     PropertyConjunction returns LTLPattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns LTLPattern
	 *     PropertyNegation returns LTLPattern
	 *     AtomicProperty returns LTLPattern
	 *     PatternProperty returns LTLPattern
	 *     LTLPattern returns LTLPattern
	 *
	 * Constraint:
	 *     property=LTLUnary
	 */
	protected void sequence_LTLPattern(ISerializationContext context, LTLPattern semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLPattern_Property()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLPattern_Property()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLPatternAccess().getPropertyLTLUnaryParserRuleCall_1_0(), semanticObject.getProperty());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLAll
	 *     LTLQuantified returns LTLAll
	 *     LTLDisjunction returns LTLAll
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLAll
	 *     LTLImplication returns LTLAll
	 *     LTLImplication.LTLImplication_1_0 returns LTLAll
	 *     LTLConjunction returns LTLAll
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLAll
	 *     LTLBinary returns LTLAll
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLAll
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLAll
	 *     LTLUnary returns LTLAll
	 *     AtomicLTL returns LTLAll
	 *
	 * Constraint:
	 *     (index=VariableDeclaration type=RangeType child=LTLQuantified)
	 */
	protected void sequence_LTLQuantified(ISerializationContext context, LTLAll semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLAll_Index()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLAll_Index()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLAll_Type()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLAll_Type()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLAll_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLAll_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLQuantifiedAccess().getIndexVariableDeclarationParserRuleCall_0_1_0(), semanticObject.getIndex());
		feeder.accept(grammarAccess.getLTLQuantifiedAccess().getTypeRangeTypeParserRuleCall_0_3_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getLTLQuantifiedAccess().getChildLTLQuantifiedParserRuleCall_0_5_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLExists
	 *     LTLQuantified returns LTLExists
	 *     LTLDisjunction returns LTLExists
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLExists
	 *     LTLImplication returns LTLExists
	 *     LTLImplication.LTLImplication_1_0 returns LTLExists
	 *     LTLConjunction returns LTLExists
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLExists
	 *     LTLBinary returns LTLExists
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLExists
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLExists
	 *     LTLUnary returns LTLExists
	 *     AtomicLTL returns LTLExists
	 *
	 * Constraint:
	 *     (index=VariableDeclaration type=RangeType child=LTLQuantified)
	 */
	protected void sequence_LTLQuantified(ISerializationContext context, LTLExists semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLExists_Index()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLExists_Index()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLExists_Type()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLExists_Type()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLExists_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLExists_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLQuantifiedAccess().getIndexVariableDeclarationParserRuleCall_0_1_0(), semanticObject.getIndex());
		feeder.accept(grammarAccess.getLTLQuantifiedAccess().getTypeRangeTypeParserRuleCall_0_3_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getLTLQuantifiedAccess().getChildLTLQuantifiedParserRuleCall_0_5_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLUnaryAlways
	 *     LTLQuantified returns LTLUnaryAlways
	 *     LTLDisjunction returns LTLUnaryAlways
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLUnaryAlways
	 *     LTLImplication returns LTLUnaryAlways
	 *     LTLImplication.LTLImplication_1_0 returns LTLUnaryAlways
	 *     LTLConjunction returns LTLUnaryAlways
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLUnaryAlways
	 *     LTLBinary returns LTLUnaryAlways
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLUnaryAlways
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLUnaryAlways
	 *     LTLUnary returns LTLUnaryAlways
	 *     AtomicLTL returns LTLUnaryAlways
	 *
	 * Constraint:
	 *     operand=LTLUnary
	 */
	protected void sequence_LTLUnary(ISerializationContext context, LTLUnaryAlways semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLUnaryAlways_Operand()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLUnaryAlways_Operand()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLUnaryAccess().getOperandLTLUnaryParserRuleCall_0_1_0(), semanticObject.getOperand());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLUnaryEventually
	 *     LTLQuantified returns LTLUnaryEventually
	 *     LTLDisjunction returns LTLUnaryEventually
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLUnaryEventually
	 *     LTLImplication returns LTLUnaryEventually
	 *     LTLImplication.LTLImplication_1_0 returns LTLUnaryEventually
	 *     LTLConjunction returns LTLUnaryEventually
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLUnaryEventually
	 *     LTLBinary returns LTLUnaryEventually
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLUnaryEventually
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLUnaryEventually
	 *     LTLUnary returns LTLUnaryEventually
	 *     AtomicLTL returns LTLUnaryEventually
	 *
	 * Constraint:
	 *     operand=LTLUnary
	 */
	protected void sequence_LTLUnary(ISerializationContext context, LTLUnaryEventually semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLUnaryEventually_Operand()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLUnaryEventually_Operand()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLUnaryAccess().getOperandLTLUnaryParserRuleCall_0_1_0(), semanticObject.getOperand());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLUnaryNegation
	 *     LTLQuantified returns LTLUnaryNegation
	 *     LTLDisjunction returns LTLUnaryNegation
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLUnaryNegation
	 *     LTLImplication returns LTLUnaryNegation
	 *     LTLImplication.LTLImplication_1_0 returns LTLUnaryNegation
	 *     LTLConjunction returns LTLUnaryNegation
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLUnaryNegation
	 *     LTLBinary returns LTLUnaryNegation
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLUnaryNegation
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLUnaryNegation
	 *     LTLUnary returns LTLUnaryNegation
	 *     AtomicLTL returns LTLUnaryNegation
	 *
	 * Constraint:
	 *     operand=LTLUnary
	 */
	protected void sequence_LTLUnary(ISerializationContext context, LTLUnaryNegation semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLUnaryNegation_Operand()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLUnaryNegation_Operand()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLUnaryAccess().getOperandLTLUnaryParserRuleCall_0_1_0(), semanticObject.getOperand());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LTLProperty returns LTLUnaryNext
	 *     LTLQuantified returns LTLUnaryNext
	 *     LTLDisjunction returns LTLUnaryNext
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LTLUnaryNext
	 *     LTLImplication returns LTLUnaryNext
	 *     LTLImplication.LTLImplication_1_0 returns LTLUnaryNext
	 *     LTLConjunction returns LTLUnaryNext
	 *     LTLConjunction.LTLConjunction_1_0 returns LTLUnaryNext
	 *     LTLBinary returns LTLUnaryNext
	 *     LTLBinary.LTLUntil_1_0_0 returns LTLUnaryNext
	 *     LTLBinary.LTLRelease_1_1_0 returns LTLUnaryNext
	 *     LTLUnary returns LTLUnaryNext
	 *     AtomicLTL returns LTLUnaryNext
	 *
	 * Constraint:
	 *     operand=LTLUnary
	 */
	protected void sequence_LTLUnary(ISerializationContext context, LTLUnaryNext semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getLTLUnaryNext_Operand()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getLTLUnaryNext_Operand()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLTLUnaryAccess().getOperandLTLUnaryParserRuleCall_0_1_0(), semanticObject.getOperand());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SequencePattern.LeadsToPattern_1_0_1 returns LeaveStateEvent
	 *     SequencePattern.PrecedesPattern_1_1_1 returns LeaveStateEvent
	 *     LTLProperty returns LeaveStateEvent
	 *     LTLQuantified returns LeaveStateEvent
	 *     LTLDisjunction returns LeaveStateEvent
	 *     LTLDisjunction.LTLDisjunction_1_0 returns LeaveStateEvent
	 *     LTLImplication returns LeaveStateEvent
	 *     LTLImplication.LTLImplication_1_0 returns LeaveStateEvent
	 *     LTLConjunction returns LeaveStateEvent
	 *     LTLConjunction.LTLConjunction_1_0 returns LeaveStateEvent
	 *     LTLBinary returns LeaveStateEvent
	 *     LTLBinary.LTLUntil_1_0_0 returns LeaveStateEvent
	 *     LTLBinary.LTLRelease_1_1_0 returns LeaveStateEvent
	 *     LTLUnary returns LeaveStateEvent
	 *     AtomicLTL returns LeaveStateEvent
	 *     StateEvent returns LeaveStateEvent
	 *     LeaveStateEvent returns LeaveStateEvent
	 *     Observable returns LeaveStateEvent
	 *     ObservableDisjunction returns LeaveStateEvent
	 *     ObservableDisjunction.ObservableDisjunction_1_0 returns LeaveStateEvent
	 *     ObservableImplication returns LeaveStateEvent
	 *     ObservableImplication.ObservableImplication_1_0 returns LeaveStateEvent
	 *     ObservableConjunction returns LeaveStateEvent
	 *     ObservableConjunction.ObservableConjunction_1_0 returns LeaveStateEvent
	 *     ObservableNegation returns LeaveStateEvent
	 *     AtomicObservable returns LeaveStateEvent
	 *     ObservableEvent returns LeaveStateEvent
	 *
	 * Constraint:
	 *     subject=AtomicObservable
	 */
	protected void sequence_LeaveStateEvent(ISerializationContext context, LeaveStateEvent semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getStateEvent_Subject()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getStateEvent_Subject()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getLeaveStateEventAccess().getSubjectAtomicObservableParserRuleCall_1_0(), semanticObject.getSubject());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LocalPortsDeclaration returns LocalPortsDeclaration
	 *
	 * Constraint:
	 *     (ports+=PortDeclaration ports+=PortDeclaration* type=ChannelType (left=LowerBound right=UpperBound)?)
	 */
	protected void sequence_LocalPortsDeclaration(ISerializationContext context, LocalPortsDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns LoopStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns LoopStatement
	 *     StatementChoice returns LoopStatement
	 *     StatementChoice.StatementChoice_1_0 returns LoopStatement
	 *     StatementSequence returns LoopStatement
	 *     StatementSequence.StatementSequence_1_0 returns LoopStatement
	 *     Statement returns LoopStatement
	 *     LoopStatement returns LoopStatement
	 *
	 * Constraint:
	 *     {LoopStatement}
	 */
	protected void sequence_LoopStatement(ISerializationContext context, LoopStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Model returns Model
	 *
	 * Constraint:
	 *     (imports+=ImportDeclaration* (declarations+=Declaration | requirements+=Requirement | root+=Root)*)
	 */
	protected void sequence_Model(ISerializationContext context, Model semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Modulo
	 *     QuantifiedExpression returns Modulo
	 *     Conditional returns Modulo
	 *     Conditional.Conditional_1_1 returns Modulo
	 *     Disjunction returns Modulo
	 *     Disjunction.Disjunction_1_0 returns Modulo
	 *     Implication returns Modulo
	 *     Implication.Implication_1_0 returns Modulo
	 *     Conjunction returns Modulo
	 *     Conjunction.Conjunction_1_0 returns Modulo
	 *     Comparison returns Modulo
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Modulo
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Modulo
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Modulo
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Modulo
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Modulo
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Modulo
	 *     Addition returns Modulo
	 *     Addition.Addition_1_0 returns Modulo
	 *     Substraction returns Modulo
	 *     Substraction.Substraction_1_0 returns Modulo
	 *     Multiplication returns Modulo
	 *     Multiplication.Multiplication_1_0 returns Modulo
	 *     Division returns Modulo
	 *     Division.Division_1_0 returns Modulo
	 *     Modulo returns Modulo
	 *     Modulo.Modulo_1_0 returns Modulo
	 *     UnaryExpression returns Modulo
	 *     Projection returns Modulo
	 *     Projection.Projection_1_0 returns Modulo
	 *     AtomicExpression returns Modulo
	 *
	 * Constraint:
	 *     (left=Modulo_Modulo_1_0 right=UnaryExpression)
	 */
	protected void sequence_Modulo(ISerializationContext context, Modulo semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getModulo_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getModulo_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getModulo_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getModulo_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getModuloAccess().getModuloLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getModuloAccess().getRightUnaryExpressionParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns MortalPattern
	 *     QuantifiedProperty returns MortalPattern
	 *     PropertyDisjunction returns MortalPattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns MortalPattern
	 *     PropertyImplication returns MortalPattern
	 *     PropertyImplication.PropertyImplication_1_0 returns MortalPattern
	 *     PropertyConjunction returns MortalPattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns MortalPattern
	 *     PropertyNegation returns MortalPattern
	 *     AtomicProperty returns MortalPattern
	 *     PatternProperty returns MortalPattern
	 *     MortalPattern returns MortalPattern
	 *
	 * Constraint:
	 *     subject=AtomicObservable
	 */
	protected void sequence_MortalPattern(ISerializationContext context, MortalPattern semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getMortalPattern_Subject()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getMortalPattern_Subject()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getMortalPatternAccess().getSubjectAtomicObservableParserRuleCall_1_0(), semanticObject.getSubject());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Multiplication
	 *     QuantifiedExpression returns Multiplication
	 *     Conditional returns Multiplication
	 *     Conditional.Conditional_1_1 returns Multiplication
	 *     Disjunction returns Multiplication
	 *     Disjunction.Disjunction_1_0 returns Multiplication
	 *     Implication returns Multiplication
	 *     Implication.Implication_1_0 returns Multiplication
	 *     Conjunction returns Multiplication
	 *     Conjunction.Conjunction_1_0 returns Multiplication
	 *     Comparison returns Multiplication
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Multiplication
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Multiplication
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Multiplication
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Multiplication
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Multiplication
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Multiplication
	 *     Addition returns Multiplication
	 *     Addition.Addition_1_0 returns Multiplication
	 *     Substraction returns Multiplication
	 *     Substraction.Substraction_1_0 returns Multiplication
	 *     Multiplication returns Multiplication
	 *     Multiplication.Multiplication_1_0 returns Multiplication
	 *     Division returns Multiplication
	 *     Division.Division_1_0 returns Multiplication
	 *     Modulo returns Multiplication
	 *     Modulo.Modulo_1_0 returns Multiplication
	 *     UnaryExpression returns Multiplication
	 *     Projection returns Multiplication
	 *     Projection.Projection_1_0 returns Multiplication
	 *     AtomicExpression returns Multiplication
	 *
	 * Constraint:
	 *     (left=Multiplication_Multiplication_1_0 right=Division)
	 */
	protected void sequence_Multiplication(ISerializationContext context, Multiplication semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getMultiplication_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getMultiplication_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getMultiplication_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getMultiplication_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getMultiplicationAccess().getMultiplicationLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getMultiplicationAccess().getRightDivisionParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     PathItem returns NamedItem
	 *     NamedItem returns NamedItem
	 *
	 * Constraint:
	 *     declaration=[PathDeclarationUse|ID]
	 */
	protected void sequence_NamedItem(ISerializationContext context, NamedItem semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedItem_Declaration()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedItem_Declaration()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getNamedItemAccess().getDeclarationPathDeclarationUseIDTerminalRuleCall_0_1(), semanticObject.getDeclaration());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     PathItem returns NaturalItem
	 *     NaturalItem returns NaturalItem
	 *
	 * Constraint:
	 *     value=INT
	 */
	protected void sequence_NaturalItem(ISerializationContext context, NaturalItem semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNaturalItem_Value()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNaturalItem_Value()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getNaturalItemAccess().getValueINTTerminalRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns NaturalLiteral
	 *     QuantifiedExpression returns NaturalLiteral
	 *     Conditional returns NaturalLiteral
	 *     Conditional.Conditional_1_1 returns NaturalLiteral
	 *     Disjunction returns NaturalLiteral
	 *     Disjunction.Disjunction_1_0 returns NaturalLiteral
	 *     Implication returns NaturalLiteral
	 *     Implication.Implication_1_0 returns NaturalLiteral
	 *     Conjunction returns NaturalLiteral
	 *     Conjunction.Conjunction_1_0 returns NaturalLiteral
	 *     Comparison returns NaturalLiteral
	 *     Comparison.ComparisonEqual_1_0_0_0 returns NaturalLiteral
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns NaturalLiteral
	 *     Comparison.ComparisonLesser_1_0_2_0 returns NaturalLiteral
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns NaturalLiteral
	 *     Comparison.ComparisonGreater_1_0_4_0 returns NaturalLiteral
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns NaturalLiteral
	 *     Addition returns NaturalLiteral
	 *     Addition.Addition_1_0 returns NaturalLiteral
	 *     Substraction returns NaturalLiteral
	 *     Substraction.Substraction_1_0 returns NaturalLiteral
	 *     Multiplication returns NaturalLiteral
	 *     Multiplication.Multiplication_1_0 returns NaturalLiteral
	 *     Division returns NaturalLiteral
	 *     Division.Division_1_0 returns NaturalLiteral
	 *     Modulo returns NaturalLiteral
	 *     Modulo.Modulo_1_0 returns NaturalLiteral
	 *     UnaryExpression returns NaturalLiteral
	 *     Projection returns NaturalLiteral
	 *     Projection.Projection_1_0 returns NaturalLiteral
	 *     ValueExpression returns NaturalLiteral
	 *     AtomicExpression returns NaturalLiteral
	 *     LiteralExpression returns NaturalLiteral
	 *     NaturalLiteral returns NaturalLiteral
	 *
	 * Constraint:
	 *     value=INT
	 */
	protected void sequence_NaturalLiteral(ISerializationContext context, NaturalLiteral semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNaturalLiteral_Value()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNaturalLiteral_Value()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getNaturalLiteralAccess().getValueINTTerminalRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LowerBound returns NaturalLowerBound
	 *     NaturalLowerBound returns NaturalLowerBound
	 *
	 * Constraint:
	 *     ((left?='[' | right?=']') value=INT)
	 */
	protected void sequence_NaturalLowerBound(ISerializationContext context, NaturalLowerBound semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UpperBound returns NaturalUpperBound
	 *     NaturalUpperBound returns NaturalUpperBound
	 *
	 * Constraint:
	 *     (value=INT (left?='[' | right?=']'))
	 */
	protected void sequence_NaturalUpperBound(ISerializationContext context, NaturalUpperBound semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns NullStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns NullStatement
	 *     StatementChoice returns NullStatement
	 *     StatementChoice.StatementChoice_1_0 returns NullStatement
	 *     StatementSequence returns NullStatement
	 *     StatementSequence.StatementSequence_1_0 returns NullStatement
	 *     Statement returns NullStatement
	 *     NullStatement returns NullStatement
	 *
	 * Constraint:
	 *     {NullStatement}
	 */
	protected void sequence_NullStatement(ISerializationContext context, NullStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SequencePattern.LeadsToPattern_1_0_1 returns ObservableConjunction
	 *     SequencePattern.PrecedesPattern_1_1_1 returns ObservableConjunction
	 *     Observable returns ObservableConjunction
	 *     ObservableDisjunction returns ObservableConjunction
	 *     ObservableDisjunction.ObservableDisjunction_1_0 returns ObservableConjunction
	 *     ObservableImplication returns ObservableConjunction
	 *     ObservableImplication.ObservableImplication_1_0 returns ObservableConjunction
	 *     ObservableConjunction returns ObservableConjunction
	 *     ObservableConjunction.ObservableConjunction_1_0 returns ObservableConjunction
	 *     ObservableNegation returns ObservableConjunction
	 *     AtomicObservable returns ObservableConjunction
	 *
	 * Constraint:
	 *     (left=ObservableConjunction_ObservableConjunction_1_0 right=ObservableNegation)
	 */
	protected void sequence_ObservableConjunction(ISerializationContext context, ObservableConjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getObservableConjunction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getObservableConjunction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getObservableConjunction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getObservableConjunction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getObservableConjunctionAccess().getObservableConjunctionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getObservableConjunctionAccess().getRightObservableNegationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SequencePattern.LeadsToPattern_1_0_1 returns ObservableDisjunction
	 *     SequencePattern.PrecedesPattern_1_1_1 returns ObservableDisjunction
	 *     Observable returns ObservableDisjunction
	 *     ObservableDisjunction returns ObservableDisjunction
	 *     ObservableDisjunction.ObservableDisjunction_1_0 returns ObservableDisjunction
	 *     ObservableImplication returns ObservableDisjunction
	 *     ObservableImplication.ObservableImplication_1_0 returns ObservableDisjunction
	 *     ObservableConjunction returns ObservableDisjunction
	 *     ObservableConjunction.ObservableConjunction_1_0 returns ObservableDisjunction
	 *     ObservableNegation returns ObservableDisjunction
	 *     AtomicObservable returns ObservableDisjunction
	 *
	 * Constraint:
	 *     (left=ObservableDisjunction_ObservableDisjunction_1_0 right=ObservableImplication)
	 */
	protected void sequence_ObservableDisjunction(ISerializationContext context, ObservableDisjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getObservableDisjunction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getObservableDisjunction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getObservableDisjunction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getObservableDisjunction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getObservableDisjunctionAccess().getObservableDisjunctionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getObservableDisjunctionAccess().getRightObservableImplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SequencePattern.LeadsToPattern_1_0_1 returns ObservableImplication
	 *     SequencePattern.PrecedesPattern_1_1_1 returns ObservableImplication
	 *     Observable returns ObservableImplication
	 *     ObservableDisjunction returns ObservableImplication
	 *     ObservableDisjunction.ObservableDisjunction_1_0 returns ObservableImplication
	 *     ObservableImplication returns ObservableImplication
	 *     ObservableImplication.ObservableImplication_1_0 returns ObservableImplication
	 *     ObservableConjunction returns ObservableImplication
	 *     ObservableConjunction.ObservableConjunction_1_0 returns ObservableImplication
	 *     ObservableNegation returns ObservableImplication
	 *     AtomicObservable returns ObservableImplication
	 *
	 * Constraint:
	 *     (left=ObservableImplication_ObservableImplication_1_0 right=ObservableImplication)
	 */
	protected void sequence_ObservableImplication(ISerializationContext context, ObservableImplication semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getObservableImplication_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getObservableImplication_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getObservableImplication_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getObservableImplication_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getObservableImplicationAccess().getObservableImplicationLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getObservableImplicationAccess().getRightObservableImplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     SequencePattern.LeadsToPattern_1_0_1 returns ObservableNegation
	 *     SequencePattern.PrecedesPattern_1_1_1 returns ObservableNegation
	 *     Observable returns ObservableNegation
	 *     ObservableDisjunction returns ObservableNegation
	 *     ObservableDisjunction.ObservableDisjunction_1_0 returns ObservableNegation
	 *     ObservableImplication returns ObservableNegation
	 *     ObservableImplication.ObservableImplication_1_0 returns ObservableNegation
	 *     ObservableConjunction returns ObservableNegation
	 *     ObservableConjunction.ObservableConjunction_1_0 returns ObservableNegation
	 *     ObservableNegation returns ObservableNegation
	 *     AtomicObservable returns ObservableNegation
	 *
	 * Constraint:
	 *     child=ObservableNegation
	 */
	protected void sequence_ObservableNegation(ISerializationContext context, ObservableNegation semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getObservableNegation_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getObservableNegation_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getObservableNegationAccess().getChildObservableNegationParserRuleCall_0_2_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns OnStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns OnStatement
	 *     StatementChoice returns OnStatement
	 *     StatementChoice.StatementChoice_1_0 returns OnStatement
	 *     StatementSequence returns OnStatement
	 *     StatementSequence.StatementSequence_1_0 returns OnStatement
	 *     Statement returns OnStatement
	 *     OnStatement returns OnStatement
	 *
	 * Constraint:
	 *     condition=Expression
	 */
	protected void sequence_OnStatement(ISerializationContext context, OnStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getOnStatement_Condition()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getOnStatement_Condition()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getOnStatementAccess().getConditionExpressionParserRuleCall_1_0(), semanticObject.getCondition());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns ParameterDeclaration
	 *     ExpressionDeclarationUse returns ParameterDeclaration
	 *     ReferenceDeclarationUse returns ParameterDeclaration
	 *     PatternDeclarationUse returns ParameterDeclaration
	 *     ParameterDeclaration returns ParameterDeclaration
	 *
	 * Constraint:
	 *     ((reference?='&' (array?='[' size=Expression)?)? name=ID)
	 */
	protected void sequence_ParameterDeclaration(ISerializationContext context, ParameterDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ParametersDeclaration returns ParametersDeclaration
	 *
	 * Constraint:
	 *     (parameters+=ParameterDeclaration parameters+=ParameterDeclaration* read?='read'? write?='write'? type=Type)
	 */
	protected void sequence_ParametersDeclaration(ISerializationContext context, ParametersDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     SequencePattern.LeadsToPattern_1_0_1 returns PathEvent
	 *     SequencePattern.PrecedesPattern_1_1_1 returns PathEvent
	 *     LTLProperty returns PathEvent
	 *     LTLQuantified returns PathEvent
	 *     LTLDisjunction returns PathEvent
	 *     LTLDisjunction.LTLDisjunction_1_0 returns PathEvent
	 *     LTLImplication returns PathEvent
	 *     LTLImplication.LTLImplication_1_0 returns PathEvent
	 *     LTLConjunction returns PathEvent
	 *     LTLConjunction.LTLConjunction_1_0 returns PathEvent
	 *     LTLBinary returns PathEvent
	 *     LTLBinary.LTLUntil_1_0_0 returns PathEvent
	 *     LTLBinary.LTLRelease_1_1_0 returns PathEvent
	 *     LTLUnary returns PathEvent
	 *     AtomicLTL returns PathEvent
	 *     Observable returns PathEvent
	 *     ObservableDisjunction returns PathEvent
	 *     ObservableDisjunction.ObservableDisjunction_1_0 returns PathEvent
	 *     ObservableImplication returns PathEvent
	 *     ObservableImplication.ObservableImplication_1_0 returns PathEvent
	 *     ObservableConjunction returns PathEvent
	 *     ObservableConjunction.ObservableConjunction_1_0 returns PathEvent
	 *     ObservableNegation returns PathEvent
	 *     AtomicObservable returns PathEvent
	 *     ObservableEvent returns PathEvent
	 *     PathEvent returns PathEvent
	 *
	 * Constraint:
	 *     (path=Path item=Subject)
	 */
	protected void sequence_PathEvent(ISerializationContext context, PathEvent semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPathEvent_Path()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPathEvent_Path()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPathEvent_Item()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPathEvent_Item()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPathEventAccess().getPathPathParserRuleCall_0_0(), semanticObject.getPath());
		feeder.accept(grammarAccess.getPathEventAccess().getItemSubjectParserRuleCall_1_0(), semanticObject.getItem());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Path returns Path
	 *
	 * Constraint:
	 *     items+=PathItem+
	 */
	protected void sequence_Path(ISerializationContext context, Path semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns AssignAnyStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns AssignAnyStatement
	 *     StatementChoice returns AssignAnyStatement
	 *     StatementChoice.StatementChoice_1_0 returns AssignAnyStatement
	 *     StatementSequence returns AssignAnyStatement
	 *     StatementSequence.StatementSequence_1_0 returns AssignAnyStatement
	 *     Statement returns AssignAnyStatement
	 *     PatternStatement returns AssignAnyStatement
	 *
	 * Constraint:
	 *     (
	 *         (patterns+=PatternStatement_AssignAnyStatement_1_2_1 patterns+=Pattern patterns+=Pattern* exp=Expression?) | 
	 *         (patterns+=PatternStatement_AssignAnyStatement_1_3_1 exp=Expression?)
	 *     )
	 */
	protected void sequence_PatternStatement(ISerializationContext context, AssignAnyStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns AssignStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns AssignStatement
	 *     StatementChoice returns AssignStatement
	 *     StatementChoice.StatementChoice_1_0 returns AssignStatement
	 *     StatementSequence returns AssignStatement
	 *     StatementSequence.StatementSequence_1_0 returns AssignStatement
	 *     Statement returns AssignStatement
	 *     PatternStatement returns AssignStatement
	 *
	 * Constraint:
	 *     (
	 *         (patterns+=PatternStatement_AssignStatement_1_0_1 patterns+=Pattern patterns+=Pattern* values+=Expression values+=Expression*) | 
	 *         (patterns+=PatternStatement_AssignStatement_1_1_1 values+=Expression values+=Expression*)
	 *     )
	 */
	protected void sequence_PatternStatement(ISerializationContext context, AssignStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns ReceiveStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns ReceiveStatement
	 *     StatementChoice returns ReceiveStatement
	 *     StatementChoice.StatementChoice_1_0 returns ReceiveStatement
	 *     StatementSequence returns ReceiveStatement
	 *     StatementSequence.StatementSequence_1_0 returns ReceiveStatement
	 *     Statement returns ReceiveStatement
	 *     PatternStatement returns ReceiveStatement
	 *
	 * Constraint:
	 *     (port=PatternStatement_ReceiveStatement_1_5_1 patterns+=Pattern patterns+=Pattern* exp=Expression?)
	 */
	protected void sequence_PatternStatement(ISerializationContext context, ReceiveStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns SendStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns SendStatement
	 *     StatementChoice returns SendStatement
	 *     StatementChoice.StatementChoice_1_0 returns SendStatement
	 *     StatementSequence returns SendStatement
	 *     StatementSequence.StatementSequence_1_0 returns SendStatement
	 *     Statement returns SendStatement
	 *     PatternStatement returns SendStatement
	 *
	 * Constraint:
	 *     (port=PatternStatement_SendStatement_1_4_1 values+=Expression values+=Expression*)
	 */
	protected void sequence_PatternStatement(ISerializationContext context, SendStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns PortDeclaration
	 *     ExpressionDeclarationUse returns PortDeclaration
	 *     PatternDeclarationUse returns PortDeclaration
	 *     PortDeclaration returns PortDeclaration
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_PortDeclaration(ISerializationContext context, PortDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPortDeclarationAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     PortSet returns PortSet
	 *
	 * Constraint:
	 *     (allPorts?='*' | (ports+=Expression ports+=Expression*))
	 */
	protected void sequence_PortSet(ISerializationContext context, PortSet semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     PortsDeclaration returns PortsDeclaration
	 *
	 * Constraint:
	 *     (ports+=PortDeclaration ports+=PortDeclaration* type=ChannelType)
	 */
	protected void sequence_PortsDeclaration(ISerializationContext context, PortsDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Property returns PresencePattern
	 *     QuantifiedProperty returns PresencePattern
	 *     PropertyDisjunction returns PresencePattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns PresencePattern
	 *     PropertyImplication returns PresencePattern
	 *     PropertyImplication.PropertyImplication_1_0 returns PresencePattern
	 *     PropertyConjunction returns PresencePattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns PresencePattern
	 *     PropertyNegation returns PresencePattern
	 *     AtomicProperty returns PresencePattern
	 *     PatternProperty returns PresencePattern
	 *     PresencePattern returns PresencePattern
	 *
	 * Constraint:
	 *     (
	 *         subject=AtomicObservable 
	 *         (
	 *             lasting=INT | 
	 *             (after=AtomicObservable ((lower=LowerBound upper=UpperBound) | until=AtomicObservable)?) | 
	 *             (before=AtomicObservable (lower=LowerBound upper=UpperBound)?) | 
	 *             (min=AtomicObservable max=AtomicObservable)
	 *         )?
	 *     )
	 */
	protected void sequence_PresencePattern(ISerializationContext context, PresencePattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     PriorityDeclaration returns PriorityDeclaration
	 *
	 * Constraint:
	 *     (groups+=PriorityGroup groups+=PriorityGroup+)
	 */
	protected void sequence_PriorityDeclaration(ISerializationContext context, PriorityDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     PriorityGroup returns PriorityGroup
	 *
	 * Constraint:
	 *     (ports+=[PortDeclaration|ID] ports+=[PortDeclaration|ID]*)
	 */
	protected void sequence_PriorityGroup(ISerializationContext context, PriorityGroup semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     RootDeclaration returns ProcessDeclaration
	 *     NamedElement returns ProcessDeclaration
	 *     PathDeclarationUse returns ProcessDeclaration
	 *     Declaration returns ProcessDeclaration
	 *     ParameterizedDeclaration returns ProcessDeclaration
	 *     ProcessDeclaration returns ProcessDeclaration
	 *
	 * Constraint:
	 *     (
	 *         name=ID 
	 *         (ports+=PortsDeclaration ports+=PortsDeclaration*)? 
	 *         (parameters+=ParametersDeclaration parameters+=ParametersDeclaration*)? 
	 *         (localPorts+=PortsDeclaration localPorts+=PortsDeclaration*)? 
	 *         (priorities+=PriorityDeclaration priorities+=PriorityDeclaration*)? 
	 *         states+=StateDeclaration 
	 *         states+=StateDeclaration* 
	 *         (variables+=VariablesDeclaration variables+=VariablesDeclaration*)? 
	 *         prelude=StatementSequence? 
	 *         transitions+=Transition+
	 *     )
	 */
	protected void sequence_ProcessDeclaration(ISerializationContext context, ProcessDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Projection
	 *     QuantifiedExpression returns Projection
	 *     Conditional returns Projection
	 *     Conditional.Conditional_1_1 returns Projection
	 *     Disjunction returns Projection
	 *     Disjunction.Disjunction_1_0 returns Projection
	 *     Implication returns Projection
	 *     Implication.Implication_1_0 returns Projection
	 *     Conjunction returns Projection
	 *     Conjunction.Conjunction_1_0 returns Projection
	 *     Comparison returns Projection
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Projection
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Projection
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Projection
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Projection
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Projection
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Projection
	 *     Addition returns Projection
	 *     Addition.Addition_1_0 returns Projection
	 *     Substraction returns Projection
	 *     Substraction.Substraction_1_0 returns Projection
	 *     Multiplication returns Projection
	 *     Multiplication.Multiplication_1_0 returns Projection
	 *     Division returns Projection
	 *     Division.Division_1_0 returns Projection
	 *     Modulo returns Projection
	 *     Modulo.Modulo_1_0 returns Projection
	 *     UnaryExpression returns Projection
	 *     Projection returns Projection
	 *     Projection.Projection_1_0 returns Projection
	 *     AtomicExpression returns Projection
	 *
	 * Constraint:
	 *     (channel=Projection_Projection_1_0 field=AtomicExpression)
	 */
	protected void sequence_Projection(ISerializationContext context, Projection semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getProjection_Channel()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getProjection_Channel()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getProjection_Field()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getProjection_Field()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getProjectionAccess().getProjectionChannelAction_1_0(), semanticObject.getChannel());
		feeder.accept(grammarAccess.getProjectionAccess().getFieldAtomicExpressionParserRuleCall_1_2_0(), semanticObject.getField());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns PropertyConjunction
	 *     QuantifiedProperty returns PropertyConjunction
	 *     PropertyDisjunction returns PropertyConjunction
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns PropertyConjunction
	 *     PropertyImplication returns PropertyConjunction
	 *     PropertyImplication.PropertyImplication_1_0 returns PropertyConjunction
	 *     PropertyConjunction returns PropertyConjunction
	 *     PropertyConjunction.PropertyConjunction_1_0 returns PropertyConjunction
	 *     PropertyNegation returns PropertyConjunction
	 *     AtomicProperty returns PropertyConjunction
	 *
	 * Constraint:
	 *     (left=PropertyConjunction_PropertyConjunction_1_0 right=PropertyNegation)
	 */
	protected void sequence_PropertyConjunction(ISerializationContext context, PropertyConjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPropertyConjunction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPropertyConjunction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPropertyConjunction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPropertyConjunction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPropertyConjunctionAccess().getPropertyConjunctionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getPropertyConjunctionAccess().getRightPropertyNegationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns PropertyDeclaration
	 *     PropertyDeclarationUse returns PropertyDeclaration
	 *     Declaration returns PropertyDeclaration
	 *     PropertyDeclaration returns PropertyDeclaration
	 *
	 * Constraint:
	 *     (name=ID property=Property)
	 */
	protected void sequence_PropertyDeclaration(ISerializationContext context, PropertyDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPropertyDeclaration_Property()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPropertyDeclaration_Property()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPropertyDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getPropertyDeclarationAccess().getPropertyPropertyParserRuleCall_3_0(), semanticObject.getProperty());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns PropertyDisjunction
	 *     QuantifiedProperty returns PropertyDisjunction
	 *     PropertyDisjunction returns PropertyDisjunction
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns PropertyDisjunction
	 *     PropertyImplication returns PropertyDisjunction
	 *     PropertyImplication.PropertyImplication_1_0 returns PropertyDisjunction
	 *     PropertyConjunction returns PropertyDisjunction
	 *     PropertyConjunction.PropertyConjunction_1_0 returns PropertyDisjunction
	 *     PropertyNegation returns PropertyDisjunction
	 *     AtomicProperty returns PropertyDisjunction
	 *
	 * Constraint:
	 *     (left=PropertyDisjunction_PropertyDisjunction_1_0 right=PropertyImplication)
	 */
	protected void sequence_PropertyDisjunction(ISerializationContext context, PropertyDisjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPropertyDisjunction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPropertyDisjunction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPropertyDisjunction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPropertyDisjunction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPropertyDisjunctionAccess().getPropertyDisjunctionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getPropertyDisjunctionAccess().getRightPropertyImplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns PropertyImplication
	 *     QuantifiedProperty returns PropertyImplication
	 *     PropertyDisjunction returns PropertyImplication
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns PropertyImplication
	 *     PropertyImplication returns PropertyImplication
	 *     PropertyImplication.PropertyImplication_1_0 returns PropertyImplication
	 *     PropertyConjunction returns PropertyImplication
	 *     PropertyConjunction.PropertyConjunction_1_0 returns PropertyImplication
	 *     PropertyNegation returns PropertyImplication
	 *     AtomicProperty returns PropertyImplication
	 *
	 * Constraint:
	 *     (left=PropertyImplication_PropertyImplication_1_0 right=PropertyImplication)
	 */
	protected void sequence_PropertyImplication(ISerializationContext context, PropertyImplication semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPropertyImplication_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPropertyImplication_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPropertyImplication_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPropertyImplication_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPropertyImplicationAccess().getPropertyImplicationLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getPropertyImplicationAccess().getRightPropertyImplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns PropertyNegation
	 *     QuantifiedProperty returns PropertyNegation
	 *     PropertyDisjunction returns PropertyNegation
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns PropertyNegation
	 *     PropertyImplication returns PropertyNegation
	 *     PropertyImplication.PropertyImplication_1_0 returns PropertyNegation
	 *     PropertyConjunction returns PropertyNegation
	 *     PropertyConjunction.PropertyConjunction_1_0 returns PropertyNegation
	 *     PropertyNegation returns PropertyNegation
	 *     AtomicProperty returns PropertyNegation
	 *
	 * Constraint:
	 *     child=PropertyNegation
	 */
	protected void sequence_PropertyNegation(ISerializationContext context, PropertyNegation semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getPropertyNegation_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getPropertyNegation_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPropertyNegationAccess().getChildPropertyNegationParserRuleCall_0_2_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns AllExpression
	 *     QuantifiedExpression returns AllExpression
	 *     Conditional returns AllExpression
	 *     Conditional.Conditional_1_1 returns AllExpression
	 *     Disjunction returns AllExpression
	 *     Disjunction.Disjunction_1_0 returns AllExpression
	 *     Implication returns AllExpression
	 *     Implication.Implication_1_0 returns AllExpression
	 *     Conjunction returns AllExpression
	 *     Conjunction.Conjunction_1_0 returns AllExpression
	 *     Comparison returns AllExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns AllExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns AllExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns AllExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns AllExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns AllExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns AllExpression
	 *     Addition returns AllExpression
	 *     Addition.Addition_1_0 returns AllExpression
	 *     Substraction returns AllExpression
	 *     Substraction.Substraction_1_0 returns AllExpression
	 *     Multiplication returns AllExpression
	 *     Multiplication.Multiplication_1_0 returns AllExpression
	 *     Division returns AllExpression
	 *     Division.Division_1_0 returns AllExpression
	 *     Modulo returns AllExpression
	 *     Modulo.Modulo_1_0 returns AllExpression
	 *     UnaryExpression returns AllExpression
	 *     Projection returns AllExpression
	 *     Projection.Projection_1_0 returns AllExpression
	 *     AtomicExpression returns AllExpression
	 *
	 * Constraint:
	 *     (index=VariableDeclaration type=RangeType? child=QuantifiedExpression)
	 */
	protected void sequence_QuantifiedExpression(ISerializationContext context, AllExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ExistsExpression
	 *     QuantifiedExpression returns ExistsExpression
	 *     Conditional returns ExistsExpression
	 *     Conditional.Conditional_1_1 returns ExistsExpression
	 *     Disjunction returns ExistsExpression
	 *     Disjunction.Disjunction_1_0 returns ExistsExpression
	 *     Implication returns ExistsExpression
	 *     Implication.Implication_1_0 returns ExistsExpression
	 *     Conjunction returns ExistsExpression
	 *     Conjunction.Conjunction_1_0 returns ExistsExpression
	 *     Comparison returns ExistsExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ExistsExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ExistsExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ExistsExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ExistsExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ExistsExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ExistsExpression
	 *     Addition returns ExistsExpression
	 *     Addition.Addition_1_0 returns ExistsExpression
	 *     Substraction returns ExistsExpression
	 *     Substraction.Substraction_1_0 returns ExistsExpression
	 *     Multiplication returns ExistsExpression
	 *     Multiplication.Multiplication_1_0 returns ExistsExpression
	 *     Division returns ExistsExpression
	 *     Division.Division_1_0 returns ExistsExpression
	 *     Modulo returns ExistsExpression
	 *     Modulo.Modulo_1_0 returns ExistsExpression
	 *     UnaryExpression returns ExistsExpression
	 *     Projection returns ExistsExpression
	 *     Projection.Projection_1_0 returns ExistsExpression
	 *     AtomicExpression returns ExistsExpression
	 *
	 * Constraint:
	 *     (index=VariableDeclaration type=RangeType? child=QuantifiedExpression)
	 */
	protected void sequence_QuantifiedExpression(ISerializationContext context, ExistsExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Property returns AllProperty
	 *     QuantifiedProperty returns AllProperty
	 *     PropertyDisjunction returns AllProperty
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns AllProperty
	 *     PropertyImplication returns AllProperty
	 *     PropertyImplication.PropertyImplication_1_0 returns AllProperty
	 *     PropertyConjunction returns AllProperty
	 *     PropertyConjunction.PropertyConjunction_1_0 returns AllProperty
	 *     PropertyNegation returns AllProperty
	 *     AtomicProperty returns AllProperty
	 *
	 * Constraint:
	 *     (variable=VariableDeclaration type=RangeType child=QuantifiedProperty)
	 */
	protected void sequence_QuantifiedProperty(ISerializationContext context, AllProperty semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getAllProperty_Variable()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getAllProperty_Variable()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getAllProperty_Type()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getAllProperty_Type()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getAllProperty_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getAllProperty_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getQuantifiedPropertyAccess().getVariableVariableDeclarationParserRuleCall_0_1_0(), semanticObject.getVariable());
		feeder.accept(grammarAccess.getQuantifiedPropertyAccess().getTypeRangeTypeParserRuleCall_0_3_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getQuantifiedPropertyAccess().getChildQuantifiedPropertyParserRuleCall_0_5_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Property returns ExistsProperty
	 *     QuantifiedProperty returns ExistsProperty
	 *     PropertyDisjunction returns ExistsProperty
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns ExistsProperty
	 *     PropertyImplication returns ExistsProperty
	 *     PropertyImplication.PropertyImplication_1_0 returns ExistsProperty
	 *     PropertyConjunction returns ExistsProperty
	 *     PropertyConjunction.PropertyConjunction_1_0 returns ExistsProperty
	 *     PropertyNegation returns ExistsProperty
	 *     AtomicProperty returns ExistsProperty
	 *
	 * Constraint:
	 *     (variable=VariableDeclaration type=RangeType child=QuantifiedProperty)
	 */
	protected void sequence_QuantifiedProperty(ISerializationContext context, ExistsProperty semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getExistsProperty_Variable()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getExistsProperty_Variable()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getExistsProperty_Type()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getExistsProperty_Type()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getExistsProperty_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getExistsProperty_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getQuantifiedPropertyAccess().getVariableVariableDeclarationParserRuleCall_0_1_0(), semanticObject.getVariable());
		feeder.accept(grammarAccess.getQuantifiedPropertyAccess().getTypeRangeTypeParserRuleCall_0_3_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getQuantifiedPropertyAccess().getChildQuantifiedPropertyParserRuleCall_0_5_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns QueueExpression
	 *     QuantifiedExpression returns QueueExpression
	 *     Conditional returns QueueExpression
	 *     Conditional.Conditional_1_1 returns QueueExpression
	 *     Disjunction returns QueueExpression
	 *     Disjunction.Disjunction_1_0 returns QueueExpression
	 *     Implication returns QueueExpression
	 *     Implication.Implication_1_0 returns QueueExpression
	 *     Conjunction returns QueueExpression
	 *     Conjunction.Conjunction_1_0 returns QueueExpression
	 *     Comparison returns QueueExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns QueueExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns QueueExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns QueueExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns QueueExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns QueueExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns QueueExpression
	 *     Addition returns QueueExpression
	 *     Addition.Addition_1_0 returns QueueExpression
	 *     Substraction returns QueueExpression
	 *     Substraction.Substraction_1_0 returns QueueExpression
	 *     Multiplication returns QueueExpression
	 *     Multiplication.Multiplication_1_0 returns QueueExpression
	 *     Division returns QueueExpression
	 *     Division.Division_1_0 returns QueueExpression
	 *     Modulo returns QueueExpression
	 *     Modulo.Modulo_1_0 returns QueueExpression
	 *     UnaryExpression returns QueueExpression
	 *     Projection returns QueueExpression
	 *     Projection.Projection_1_0 returns QueueExpression
	 *     ValueExpression returns QueueExpression
	 *     AtomicExpression returns QueueExpression
	 *     QueueExpression returns QueueExpression
	 *
	 * Constraint:
	 *     (values+=Expression values+=Expression*)?
	 */
	protected void sequence_QueueExpression(ISerializationContext context, QueueExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Type returns QueueType
	 *     TupleType returns QueueType
	 *     TupleType.TupleType_1_0 returns QueueType
	 *     QueueType returns QueueType
	 *
	 * Constraint:
	 *     (size=Expression type=Type)
	 */
	protected void sequence_QueueType(ISerializationContext context, QueueType semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getQueueType_Size()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getQueueType_Size()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getQueueType_Type()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getQueueType_Type()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getQueueTypeAccess().getSizeExpressionParserRuleCall_1_0(), semanticObject.getSize());
		feeder.accept(grammarAccess.getQueueTypeAccess().getTypeTypeParserRuleCall_3_0(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Type returns RangeType
	 *     TupleType returns RangeType
	 *     TupleType.TupleType_1_0 returns RangeType
	 *     RangeType returns RangeType
	 *
	 * Constraint:
	 *     (minimum=Expression maximum=Expression)
	 */
	protected void sequence_RangeType(ISerializationContext context, RangeType semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getRangeType_Minimum()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getRangeType_Minimum()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getRangeType_Maximum()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getRangeType_Maximum()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getRangeTypeAccess().getMinimumExpressionParserRuleCall_0_0(), semanticObject.getMinimum());
		feeder.accept(grammarAccess.getRangeTypeAccess().getMaximumExpressionParserRuleCall_2_0(), semanticObject.getMaximum());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns RecordExpression
	 *     QuantifiedExpression returns RecordExpression
	 *     Conditional returns RecordExpression
	 *     Conditional.Conditional_1_1 returns RecordExpression
	 *     Disjunction returns RecordExpression
	 *     Disjunction.Disjunction_1_0 returns RecordExpression
	 *     Implication returns RecordExpression
	 *     Implication.Implication_1_0 returns RecordExpression
	 *     Conjunction returns RecordExpression
	 *     Conjunction.Conjunction_1_0 returns RecordExpression
	 *     Comparison returns RecordExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns RecordExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns RecordExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns RecordExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns RecordExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns RecordExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns RecordExpression
	 *     Addition returns RecordExpression
	 *     Addition.Addition_1_0 returns RecordExpression
	 *     Substraction returns RecordExpression
	 *     Substraction.Substraction_1_0 returns RecordExpression
	 *     Multiplication returns RecordExpression
	 *     Multiplication.Multiplication_1_0 returns RecordExpression
	 *     Division returns RecordExpression
	 *     Division.Division_1_0 returns RecordExpression
	 *     Modulo returns RecordExpression
	 *     Modulo.Modulo_1_0 returns RecordExpression
	 *     UnaryExpression returns RecordExpression
	 *     Projection returns RecordExpression
	 *     Projection.Projection_1_0 returns RecordExpression
	 *     ValueExpression returns RecordExpression
	 *     AtomicExpression returns RecordExpression
	 *     RecordExpression returns RecordExpression
	 *
	 * Constraint:
	 *     (fields+=FieldExpression fields+=FieldExpression*)
	 */
	protected void sequence_RecordExpression(ISerializationContext context, RecordExpression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns RecordFieldDeclaration
	 *     RecordFieldDeclarationUse returns RecordFieldDeclaration
	 *     RecordFieldDeclaration returns RecordFieldDeclaration
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_RecordFieldDeclaration(ISerializationContext context, RecordFieldDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getRecordFieldDeclarationAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     RecordFields returns RecordFields
	 *
	 * Constraint:
	 *     (fields+=RecordFieldDeclaration fields+=RecordFieldDeclaration* type=Type)
	 */
	protected void sequence_RecordFields(ISerializationContext context, RecordFields semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Type returns RecordType
	 *     TupleType returns RecordType
	 *     TupleType.TupleType_1_0 returns RecordType
	 *     RecordType returns RecordType
	 *
	 * Constraint:
	 *     (fields+=RecordFields fields+=RecordFields*)
	 */
	protected void sequence_RecordType(ISerializationContext context, RecordType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns ReferenceExpression
	 *     QuantifiedExpression returns ReferenceExpression
	 *     Conditional returns ReferenceExpression
	 *     Conditional.Conditional_1_1 returns ReferenceExpression
	 *     Disjunction returns ReferenceExpression
	 *     Disjunction.Disjunction_1_0 returns ReferenceExpression
	 *     Implication returns ReferenceExpression
	 *     Implication.Implication_1_0 returns ReferenceExpression
	 *     Conjunction returns ReferenceExpression
	 *     Conjunction.Conjunction_1_0 returns ReferenceExpression
	 *     Comparison returns ReferenceExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns ReferenceExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns ReferenceExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns ReferenceExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns ReferenceExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns ReferenceExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns ReferenceExpression
	 *     Addition returns ReferenceExpression
	 *     Addition.Addition_1_0 returns ReferenceExpression
	 *     Substraction returns ReferenceExpression
	 *     Substraction.Substraction_1_0 returns ReferenceExpression
	 *     Multiplication returns ReferenceExpression
	 *     Multiplication.Multiplication_1_0 returns ReferenceExpression
	 *     Division returns ReferenceExpression
	 *     Division.Division_1_0 returns ReferenceExpression
	 *     Modulo returns ReferenceExpression
	 *     Modulo.Modulo_1_0 returns ReferenceExpression
	 *     UnaryExpression returns ReferenceExpression
	 *     Projection returns ReferenceExpression
	 *     Projection.Projection_1_0 returns ReferenceExpression
	 *     AtomicExpression returns ReferenceExpression
	 *     ReferenceExpression returns ReferenceExpression
	 *
	 * Constraint:
	 *     declaration=[ReferenceDeclarationUse|ID]
	 */
	protected void sequence_ReferenceExpression(ISerializationContext context, ReferenceExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getReferenceExpression_Declaration()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getReferenceExpression_Declaration()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getReferenceExpressionAccess().getDeclarationReferenceDeclarationUseIDTerminalRuleCall_1_0_1(), semanticObject.getDeclaration());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Type returns ReferencedType
	 *     TupleType returns ReferencedType
	 *     TupleType.TupleType_1_0 returns ReferencedType
	 *     ReferencedType returns ReferencedType
	 *
	 * Constraint:
	 *     type=[TypeDeclarationUse|ID]
	 */
	protected void sequence_ReferencedType(ISerializationContext context, ReferencedType semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getReferencedType_Type()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getReferencedType_Type()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getReferencedTypeAccess().getTypeTypeDeclarationUseIDTerminalRuleCall_0_1(), semanticObject.getType());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Requirement returns Requirement
	 *
	 * Constraint:
	 *     (property=[PropertyDeclaration|ID] positive=STRING? negative=STRING?)
	 */
	protected void sequence_Requirement(ISerializationContext context, Requirement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns ReturnStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns ReturnStatement
	 *     StatementChoice returns ReturnStatement
	 *     StatementChoice.StatementChoice_1_0 returns ReturnStatement
	 *     StatementSequence returns ReturnStatement
	 *     StatementSequence.StatementSequence_1_0 returns ReturnStatement
	 *     Statement returns ReturnStatement
	 *     ReturnStatement returns ReturnStatement
	 *
	 * Constraint:
	 *     expression=Expression
	 */
	protected void sequence_ReturnStatement(ISerializationContext context, ReturnStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getReturnStatement_Expression()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getReturnStatement_Expression()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0(), semanticObject.getExpression());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Root returns Root
	 *
	 * Constraint:
	 *     (declaration=[RootDeclaration|ID] (observed+=[RootDeclaration|ID] observed+=[RootDeclaration|ID]*)?)
	 */
	protected void sequence_Root(ISerializationContext context, Root semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns SelectStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns SelectStatement
	 *     StatementChoice returns SelectStatement
	 *     StatementChoice.StatementChoice_1_0 returns SelectStatement
	 *     StatementSequence returns SelectStatement
	 *     StatementSequence.StatementSequence_1_0 returns SelectStatement
	 *     Statement returns SelectStatement
	 *     SelectStatement returns SelectStatement
	 *
	 * Constraint:
	 *     (body=UnlessStatement (index=VariableDeclaration type=RangeType)?)
	 */
	protected void sequence_SelectStatement(ISerializationContext context, SelectStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Property returns LeadsToPattern
	 *     QuantifiedProperty returns LeadsToPattern
	 *     PropertyDisjunction returns LeadsToPattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns LeadsToPattern
	 *     PropertyImplication returns LeadsToPattern
	 *     PropertyImplication.PropertyImplication_1_0 returns LeadsToPattern
	 *     PropertyConjunction returns LeadsToPattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns LeadsToPattern
	 *     PropertyNegation returns LeadsToPattern
	 *     AtomicProperty returns LeadsToPattern
	 *     PatternProperty returns LeadsToPattern
	 *     SequencePattern returns LeadsToPattern
	 *
	 * Constraint:
	 *     (
	 *         subject=SequencePattern_LeadsToPattern_1_0_1 
	 *         follower=AtomicObservable 
	 *         (
	 *             (before=AtomicObservable (lower=LowerBound upper=UpperBound)?) | 
	 *             (lower=LowerBound upper=UpperBound) | 
	 *             (after=AtomicObservable ((lower=LowerBound upper=UpperBound) | until=AtomicObservable)?) | 
	 *             (min=AtomicObservable max=AtomicObservable)
	 *         )?
	 *     )
	 */
	protected void sequence_SequencePattern(ISerializationContext context, LeadsToPattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Property returns PrecedesPattern
	 *     QuantifiedProperty returns PrecedesPattern
	 *     PropertyDisjunction returns PrecedesPattern
	 *     PropertyDisjunction.PropertyDisjunction_1_0 returns PrecedesPattern
	 *     PropertyImplication returns PrecedesPattern
	 *     PropertyImplication.PropertyImplication_1_0 returns PrecedesPattern
	 *     PropertyConjunction returns PrecedesPattern
	 *     PropertyConjunction.PropertyConjunction_1_0 returns PrecedesPattern
	 *     PropertyNegation returns PrecedesPattern
	 *     AtomicProperty returns PrecedesPattern
	 *     PatternProperty returns PrecedesPattern
	 *     SequencePattern returns PrecedesPattern
	 *
	 * Constraint:
	 *     (
	 *         subject=SequencePattern_PrecedesPattern_1_1_1 
	 *         follower=AtomicObservable 
	 *         (before=AtomicObservable | (after=AtomicObservable until=AtomicObservable?) | (min=AtomicObservable max=AtomicObservable))?
	 *     )
	 */
	protected void sequence_SequencePattern(ISerializationContext context, PrecedesPattern semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns StateDeclaration
	 *     StateDeclaration returns StateDeclaration
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_StateDeclaration(ISerializationContext context, StateDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getStateDeclarationAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Subject returns StateSubject
	 *     StateSubject returns StateSubject
	 *
	 * Constraint:
	 *     state=[StateDeclaration|ID]
	 */
	protected void sequence_StateSubject(ISerializationContext context, StateSubject semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getStateSubject_State()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getStateSubject_State()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getStateSubjectAccess().getStateStateDeclarationIDTerminalRuleCall_1_0_1(), semanticObject.getState());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns StatementChoice
	 *     UnlessStatement.UnlessStatement_1_0 returns StatementChoice
	 *     StatementChoice returns StatementChoice
	 *     StatementChoice.StatementChoice_1_0 returns StatementChoice
	 *
	 * Constraint:
	 *     (choices+=StatementChoice_StatementChoice_1_0 choices+=StatementSequence)
	 */
	protected void sequence_StatementChoice(ISerializationContext context, StatementChoice semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns StatementSequence
	 *     UnlessStatement.UnlessStatement_1_0 returns StatementSequence
	 *     StatementChoice returns StatementSequence
	 *     StatementChoice.StatementChoice_1_0 returns StatementSequence
	 *     StatementSequence returns StatementSequence
	 *     StatementSequence.StatementSequence_1_0 returns StatementSequence
	 *
	 * Constraint:
	 *     (statements+=StatementSequence_StatementSequence_1_0 statements+=Statement)
	 */
	protected void sequence_StatementSequence(ISerializationContext context, StatementSequence semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns Substraction
	 *     QuantifiedExpression returns Substraction
	 *     Conditional returns Substraction
	 *     Conditional.Conditional_1_1 returns Substraction
	 *     Disjunction returns Substraction
	 *     Disjunction.Disjunction_1_0 returns Substraction
	 *     Implication returns Substraction
	 *     Implication.Implication_1_0 returns Substraction
	 *     Conjunction returns Substraction
	 *     Conjunction.Conjunction_1_0 returns Substraction
	 *     Comparison returns Substraction
	 *     Comparison.ComparisonEqual_1_0_0_0 returns Substraction
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns Substraction
	 *     Comparison.ComparisonLesser_1_0_2_0 returns Substraction
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns Substraction
	 *     Comparison.ComparisonGreater_1_0_4_0 returns Substraction
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns Substraction
	 *     Addition returns Substraction
	 *     Addition.Addition_1_0 returns Substraction
	 *     Substraction returns Substraction
	 *     Substraction.Substraction_1_0 returns Substraction
	 *     Multiplication returns Substraction
	 *     Multiplication.Multiplication_1_0 returns Substraction
	 *     Division returns Substraction
	 *     Division.Division_1_0 returns Substraction
	 *     Modulo returns Substraction
	 *     Modulo.Modulo_1_0 returns Substraction
	 *     UnaryExpression returns Substraction
	 *     Projection returns Substraction
	 *     Projection.Projection_1_0 returns Substraction
	 *     AtomicExpression returns Substraction
	 *
	 * Constraint:
	 *     (left=Substraction_Substraction_1_0 right=Multiplication)
	 */
	protected void sequence_Substraction(ISerializationContext context, Substraction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getSubstraction_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getSubstraction_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getSubstraction_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getSubstraction_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getSubstractionAccess().getSubstractionLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getSubstractionAccess().getRightMultiplicationParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Subject returns TagSubject
	 *     TagSubject returns TagSubject
	 *
	 * Constraint:
	 *     tag=[TaggedStatement|ID]
	 */
	protected void sequence_TagSubject(ISerializationContext context, TagSubject semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getTagSubject_Tag()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getTagSubject_Tag()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getTagSubjectAccess().getTagTaggedStatementIDTerminalRuleCall_1_0_1(), semanticObject.getTag());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns TaggedStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns TaggedStatement
	 *     StatementChoice returns TaggedStatement
	 *     StatementChoice.StatementChoice_1_0 returns TaggedStatement
	 *     StatementSequence returns TaggedStatement
	 *     StatementSequence.StatementSequence_1_0 returns TaggedStatement
	 *     Statement returns TaggedStatement
	 *     TaggedStatement returns TaggedStatement
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_TaggedStatement(ISerializationContext context, TaggedStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getTaggedStatement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getTaggedStatement_Name()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getTaggedStatementAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns ToStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns ToStatement
	 *     StatementChoice returns ToStatement
	 *     StatementChoice.StatementChoice_1_0 returns ToStatement
	 *     StatementSequence returns ToStatement
	 *     StatementSequence.StatementSequence_1_0 returns ToStatement
	 *     Statement returns ToStatement
	 *     ToStatement returns ToStatement
	 *
	 * Constraint:
	 *     state=[StateDeclaration|ID]
	 */
	protected void sequence_ToStatement(ISerializationContext context, ToStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getToStatement_State()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getToStatement_State()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getToStatementAccess().getStateStateDeclarationIDTerminalRuleCall_1_0_1(), semanticObject.getState());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     TransitionSource returns TransitionSource
	 *
	 * Constraint:
	 *     origin=[StateDeclaration|ID]
	 */
	protected void sequence_TransitionSource(ISerializationContext context, TransitionSource semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getTransitionSource_Origin()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getTransitionSource_Origin()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getTransitionSourceAccess().getOriginStateDeclarationIDTerminalRuleCall_1_0_1(), semanticObject.getOrigin());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Transition returns Transition
	 *
	 * Constraint:
	 *     (source=TransitionSource action=StatementSequence)
	 */
	protected void sequence_Transition(ISerializationContext context, Transition semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getTransition_Source()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getTransition_Source()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getTransition_Action()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getTransition_Action()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getTransitionAccess().getSourceTransitionSourceParserRuleCall_0_0(), semanticObject.getSource());
		feeder.accept(grammarAccess.getTransitionAccess().getActionStatementSequenceParserRuleCall_1_0(), semanticObject.getAction());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     TupleType returns TupleType
	 *     TupleType.TupleType_1_0 returns TupleType
	 *
	 * Constraint:
	 *     (types+=TupleType_TupleType_1_0 types+=Type)
	 */
	protected void sequence_TupleType(ISerializationContext context, TupleType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns TypeDeclaration
	 *     TypeDeclarationUse returns TypeDeclaration
	 *     Declaration returns TypeDeclaration
	 *     TypeDeclaration returns TypeDeclaration
	 *
	 * Constraint:
	 *     (name=ID value=Type)
	 */
	protected void sequence_TypeDeclaration(ISerializationContext context, TypeDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getTypeDeclaration_Value()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getTypeDeclaration_Value()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getTypeDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getTypeDeclarationAccess().getValueTypeParserRuleCall_3_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryCoerceExpression
	 *     QuantifiedExpression returns UnaryCoerceExpression
	 *     Conditional returns UnaryCoerceExpression
	 *     Conditional.Conditional_1_1 returns UnaryCoerceExpression
	 *     Disjunction returns UnaryCoerceExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryCoerceExpression
	 *     Implication returns UnaryCoerceExpression
	 *     Implication.Implication_1_0 returns UnaryCoerceExpression
	 *     Conjunction returns UnaryCoerceExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryCoerceExpression
	 *     Comparison returns UnaryCoerceExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryCoerceExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryCoerceExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryCoerceExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryCoerceExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryCoerceExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryCoerceExpression
	 *     Addition returns UnaryCoerceExpression
	 *     Addition.Addition_1_0 returns UnaryCoerceExpression
	 *     Substraction returns UnaryCoerceExpression
	 *     Substraction.Substraction_1_0 returns UnaryCoerceExpression
	 *     Multiplication returns UnaryCoerceExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryCoerceExpression
	 *     Division returns UnaryCoerceExpression
	 *     Division.Division_1_0 returns UnaryCoerceExpression
	 *     Modulo returns UnaryCoerceExpression
	 *     Modulo.Modulo_1_0 returns UnaryCoerceExpression
	 *     UnaryExpression returns UnaryCoerceExpression
	 *     Projection returns UnaryCoerceExpression
	 *     Projection.Projection_1_0 returns UnaryCoerceExpression
	 *     AtomicExpression returns UnaryCoerceExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryCoerceExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryCoerceExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryCoerceExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryDeQueueExpression
	 *     QuantifiedExpression returns UnaryDeQueueExpression
	 *     Conditional returns UnaryDeQueueExpression
	 *     Conditional.Conditional_1_1 returns UnaryDeQueueExpression
	 *     Disjunction returns UnaryDeQueueExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryDeQueueExpression
	 *     Implication returns UnaryDeQueueExpression
	 *     Implication.Implication_1_0 returns UnaryDeQueueExpression
	 *     Conjunction returns UnaryDeQueueExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryDeQueueExpression
	 *     Comparison returns UnaryDeQueueExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryDeQueueExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryDeQueueExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryDeQueueExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryDeQueueExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryDeQueueExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryDeQueueExpression
	 *     Addition returns UnaryDeQueueExpression
	 *     Addition.Addition_1_0 returns UnaryDeQueueExpression
	 *     Substraction returns UnaryDeQueueExpression
	 *     Substraction.Substraction_1_0 returns UnaryDeQueueExpression
	 *     Multiplication returns UnaryDeQueueExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryDeQueueExpression
	 *     Division returns UnaryDeQueueExpression
	 *     Division.Division_1_0 returns UnaryDeQueueExpression
	 *     Modulo returns UnaryDeQueueExpression
	 *     Modulo.Modulo_1_0 returns UnaryDeQueueExpression
	 *     UnaryExpression returns UnaryDeQueueExpression
	 *     Projection returns UnaryDeQueueExpression
	 *     Projection.Projection_1_0 returns UnaryDeQueueExpression
	 *     AtomicExpression returns UnaryDeQueueExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryDeQueueExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryDeQueueExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryDeQueueExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryEmptyExpression
	 *     QuantifiedExpression returns UnaryEmptyExpression
	 *     Conditional returns UnaryEmptyExpression
	 *     Conditional.Conditional_1_1 returns UnaryEmptyExpression
	 *     Disjunction returns UnaryEmptyExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryEmptyExpression
	 *     Implication returns UnaryEmptyExpression
	 *     Implication.Implication_1_0 returns UnaryEmptyExpression
	 *     Conjunction returns UnaryEmptyExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryEmptyExpression
	 *     Comparison returns UnaryEmptyExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryEmptyExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryEmptyExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryEmptyExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryEmptyExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryEmptyExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryEmptyExpression
	 *     Addition returns UnaryEmptyExpression
	 *     Addition.Addition_1_0 returns UnaryEmptyExpression
	 *     Substraction returns UnaryEmptyExpression
	 *     Substraction.Substraction_1_0 returns UnaryEmptyExpression
	 *     Multiplication returns UnaryEmptyExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryEmptyExpression
	 *     Division returns UnaryEmptyExpression
	 *     Division.Division_1_0 returns UnaryEmptyExpression
	 *     Modulo returns UnaryEmptyExpression
	 *     Modulo.Modulo_1_0 returns UnaryEmptyExpression
	 *     UnaryExpression returns UnaryEmptyExpression
	 *     Projection returns UnaryEmptyExpression
	 *     Projection.Projection_1_0 returns UnaryEmptyExpression
	 *     AtomicExpression returns UnaryEmptyExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryEmptyExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryEmptyExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryEmptyExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryFirstExpression
	 *     QuantifiedExpression returns UnaryFirstExpression
	 *     Conditional returns UnaryFirstExpression
	 *     Conditional.Conditional_1_1 returns UnaryFirstExpression
	 *     Disjunction returns UnaryFirstExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryFirstExpression
	 *     Implication returns UnaryFirstExpression
	 *     Implication.Implication_1_0 returns UnaryFirstExpression
	 *     Conjunction returns UnaryFirstExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryFirstExpression
	 *     Comparison returns UnaryFirstExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryFirstExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryFirstExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryFirstExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryFirstExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryFirstExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryFirstExpression
	 *     Addition returns UnaryFirstExpression
	 *     Addition.Addition_1_0 returns UnaryFirstExpression
	 *     Substraction returns UnaryFirstExpression
	 *     Substraction.Substraction_1_0 returns UnaryFirstExpression
	 *     Multiplication returns UnaryFirstExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryFirstExpression
	 *     Division returns UnaryFirstExpression
	 *     Division.Division_1_0 returns UnaryFirstExpression
	 *     Modulo returns UnaryFirstExpression
	 *     Modulo.Modulo_1_0 returns UnaryFirstExpression
	 *     UnaryExpression returns UnaryFirstExpression
	 *     Projection returns UnaryFirstExpression
	 *     Projection.Projection_1_0 returns UnaryFirstExpression
	 *     AtomicExpression returns UnaryFirstExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryFirstExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryFirstExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryFirstExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryFullExpression
	 *     QuantifiedExpression returns UnaryFullExpression
	 *     Conditional returns UnaryFullExpression
	 *     Conditional.Conditional_1_1 returns UnaryFullExpression
	 *     Disjunction returns UnaryFullExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryFullExpression
	 *     Implication returns UnaryFullExpression
	 *     Implication.Implication_1_0 returns UnaryFullExpression
	 *     Conjunction returns UnaryFullExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryFullExpression
	 *     Comparison returns UnaryFullExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryFullExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryFullExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryFullExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryFullExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryFullExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryFullExpression
	 *     Addition returns UnaryFullExpression
	 *     Addition.Addition_1_0 returns UnaryFullExpression
	 *     Substraction returns UnaryFullExpression
	 *     Substraction.Substraction_1_0 returns UnaryFullExpression
	 *     Multiplication returns UnaryFullExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryFullExpression
	 *     Division returns UnaryFullExpression
	 *     Division.Division_1_0 returns UnaryFullExpression
	 *     Modulo returns UnaryFullExpression
	 *     Modulo.Modulo_1_0 returns UnaryFullExpression
	 *     UnaryExpression returns UnaryFullExpression
	 *     Projection returns UnaryFullExpression
	 *     Projection.Projection_1_0 returns UnaryFullExpression
	 *     AtomicExpression returns UnaryFullExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryFullExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryFullExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryFullExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryLengthExpression
	 *     QuantifiedExpression returns UnaryLengthExpression
	 *     Conditional returns UnaryLengthExpression
	 *     Conditional.Conditional_1_1 returns UnaryLengthExpression
	 *     Disjunction returns UnaryLengthExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryLengthExpression
	 *     Implication returns UnaryLengthExpression
	 *     Implication.Implication_1_0 returns UnaryLengthExpression
	 *     Conjunction returns UnaryLengthExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryLengthExpression
	 *     Comparison returns UnaryLengthExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryLengthExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryLengthExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryLengthExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryLengthExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryLengthExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryLengthExpression
	 *     Addition returns UnaryLengthExpression
	 *     Addition.Addition_1_0 returns UnaryLengthExpression
	 *     Substraction returns UnaryLengthExpression
	 *     Substraction.Substraction_1_0 returns UnaryLengthExpression
	 *     Multiplication returns UnaryLengthExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryLengthExpression
	 *     Division returns UnaryLengthExpression
	 *     Division.Division_1_0 returns UnaryLengthExpression
	 *     Modulo returns UnaryLengthExpression
	 *     Modulo.Modulo_1_0 returns UnaryLengthExpression
	 *     UnaryExpression returns UnaryLengthExpression
	 *     Projection returns UnaryLengthExpression
	 *     Projection.Projection_1_0 returns UnaryLengthExpression
	 *     AtomicExpression returns UnaryLengthExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryLengthExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryLengthExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryLengthExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryMinusExpression
	 *     QuantifiedExpression returns UnaryMinusExpression
	 *     Conditional returns UnaryMinusExpression
	 *     Conditional.Conditional_1_1 returns UnaryMinusExpression
	 *     Disjunction returns UnaryMinusExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryMinusExpression
	 *     Implication returns UnaryMinusExpression
	 *     Implication.Implication_1_0 returns UnaryMinusExpression
	 *     Conjunction returns UnaryMinusExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryMinusExpression
	 *     Comparison returns UnaryMinusExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryMinusExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryMinusExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryMinusExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryMinusExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryMinusExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryMinusExpression
	 *     Addition returns UnaryMinusExpression
	 *     Addition.Addition_1_0 returns UnaryMinusExpression
	 *     Substraction returns UnaryMinusExpression
	 *     Substraction.Substraction_1_0 returns UnaryMinusExpression
	 *     Multiplication returns UnaryMinusExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryMinusExpression
	 *     Division returns UnaryMinusExpression
	 *     Division.Division_1_0 returns UnaryMinusExpression
	 *     Modulo returns UnaryMinusExpression
	 *     Modulo.Modulo_1_0 returns UnaryMinusExpression
	 *     UnaryExpression returns UnaryMinusExpression
	 *     Projection returns UnaryMinusExpression
	 *     Projection.Projection_1_0 returns UnaryMinusExpression
	 *     AtomicExpression returns UnaryMinusExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryMinusExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryMinusExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryMinusExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryNegationExpression
	 *     QuantifiedExpression returns UnaryNegationExpression
	 *     Conditional returns UnaryNegationExpression
	 *     Conditional.Conditional_1_1 returns UnaryNegationExpression
	 *     Disjunction returns UnaryNegationExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryNegationExpression
	 *     Implication returns UnaryNegationExpression
	 *     Implication.Implication_1_0 returns UnaryNegationExpression
	 *     Conjunction returns UnaryNegationExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryNegationExpression
	 *     Comparison returns UnaryNegationExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryNegationExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryNegationExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryNegationExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryNegationExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryNegationExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryNegationExpression
	 *     Addition returns UnaryNegationExpression
	 *     Addition.Addition_1_0 returns UnaryNegationExpression
	 *     Substraction returns UnaryNegationExpression
	 *     Substraction.Substraction_1_0 returns UnaryNegationExpression
	 *     Multiplication returns UnaryNegationExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryNegationExpression
	 *     Division returns UnaryNegationExpression
	 *     Division.Division_1_0 returns UnaryNegationExpression
	 *     Modulo returns UnaryNegationExpression
	 *     Modulo.Modulo_1_0 returns UnaryNegationExpression
	 *     UnaryExpression returns UnaryNegationExpression
	 *     Projection returns UnaryNegationExpression
	 *     Projection.Projection_1_0 returns UnaryNegationExpression
	 *     AtomicExpression returns UnaryNegationExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryNegationExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryNegationExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryNegationExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Expression returns UnaryPlusExpression
	 *     QuantifiedExpression returns UnaryPlusExpression
	 *     Conditional returns UnaryPlusExpression
	 *     Conditional.Conditional_1_1 returns UnaryPlusExpression
	 *     Disjunction returns UnaryPlusExpression
	 *     Disjunction.Disjunction_1_0 returns UnaryPlusExpression
	 *     Implication returns UnaryPlusExpression
	 *     Implication.Implication_1_0 returns UnaryPlusExpression
	 *     Conjunction returns UnaryPlusExpression
	 *     Conjunction.Conjunction_1_0 returns UnaryPlusExpression
	 *     Comparison returns UnaryPlusExpression
	 *     Comparison.ComparisonEqual_1_0_0_0 returns UnaryPlusExpression
	 *     Comparison.ComparisonNotEqual_1_0_1_0 returns UnaryPlusExpression
	 *     Comparison.ComparisonLesser_1_0_2_0 returns UnaryPlusExpression
	 *     Comparison.ComparisonLesserEqual_1_0_3_0 returns UnaryPlusExpression
	 *     Comparison.ComparisonGreater_1_0_4_0 returns UnaryPlusExpression
	 *     Comparison.ComparisonGreaterEqual_1_0_5_0 returns UnaryPlusExpression
	 *     Addition returns UnaryPlusExpression
	 *     Addition.Addition_1_0 returns UnaryPlusExpression
	 *     Substraction returns UnaryPlusExpression
	 *     Substraction.Substraction_1_0 returns UnaryPlusExpression
	 *     Multiplication returns UnaryPlusExpression
	 *     Multiplication.Multiplication_1_0 returns UnaryPlusExpression
	 *     Division returns UnaryPlusExpression
	 *     Division.Division_1_0 returns UnaryPlusExpression
	 *     Modulo returns UnaryPlusExpression
	 *     Modulo.Modulo_1_0 returns UnaryPlusExpression
	 *     UnaryExpression returns UnaryPlusExpression
	 *     Projection returns UnaryPlusExpression
	 *     Projection.Projection_1_0 returns UnaryPlusExpression
	 *     AtomicExpression returns UnaryPlusExpression
	 *
	 * Constraint:
	 *     child=UnaryExpression
	 */
	protected void sequence_UnaryExpression(ISerializationContext context, UnaryPlusExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getUnaryPlusExpression_Child()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getUnaryPlusExpression_Child()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0(), semanticObject.getChild());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns UnionTagDeclaration
	 *     ExpressionDeclarationUse returns UnionTagDeclaration
	 *     UnionTagDeclarationUse returns UnionTagDeclaration
	 *     PatternDeclarationUse returns UnionTagDeclaration
	 *     UnionTagDeclaration returns UnionTagDeclaration
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_UnionTagDeclaration(ISerializationContext context, UnionTagDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getUnionTagDeclarationAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnionTags returns UnionTags
	 *
	 * Constraint:
	 *     (tags+=UnionTagDeclaration tags+=UnionTagDeclaration* type=Type?)
	 */
	protected void sequence_UnionTags(ISerializationContext context, UnionTags semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Type returns UnionType
	 *     TupleType returns UnionType
	 *     TupleType.TupleType_1_0 returns UnionType
	 *     UnionType returns UnionType
	 *
	 * Constraint:
	 *     (tags+=UnionTags tags+=UnionTags*)
	 */
	protected void sequence_UnionType(ISerializationContext context, UnionType semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns UnlessStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns UnlessStatement
	 *
	 * Constraint:
	 *     (followers+=UnlessStatement_UnlessStatement_1_0 followers+=StatementChoice)
	 */
	protected void sequence_UnlessStatement(ISerializationContext context, UnlessStatement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Subject returns ValueSubject
	 *     ValueSubject returns ValueSubject
	 *
	 * Constraint:
	 *     value=AtomicExpression
	 */
	protected void sequence_ValueSubject(ISerializationContext context, ValueSubject semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getValueSubject_Value()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getValueSubject_Value()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getValueSubjectAccess().getValueAtomicExpressionParserRuleCall_1_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NamedElement returns VariableDeclaration
	 *     ExpressionDeclarationUse returns VariableDeclaration
	 *     ReferenceDeclarationUse returns VariableDeclaration
	 *     PatternDeclarationUse returns VariableDeclaration
	 *     BoundDeclarationUse returns VariableDeclaration
	 *     PropertyDeclarationUse returns VariableDeclaration
	 *     VariableDeclaration returns VariableDeclaration
	 *
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_VariableDeclaration(ISerializationContext context, VariableDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getNamedElement_Name()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getVariableDeclarationAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     LowerBound returns VariableLowerBound
	 *     VariableLowerBound returns VariableLowerBound
	 *
	 * Constraint:
	 *     ((left?='[' | right?=']') variable=[BoundDeclarationUse|ID])
	 */
	protected void sequence_VariableLowerBound(ISerializationContext context, VariableLowerBound semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UpperBound returns VariableUpperBound
	 *     VariableUpperBound returns VariableUpperBound
	 *
	 * Constraint:
	 *     (variable=[BoundDeclarationUse|ID] (left?='[' | right?=']'))
	 */
	protected void sequence_VariableUpperBound(ISerializationContext context, VariableUpperBound semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     VariablesDeclaration returns VariablesDeclaration
	 *
	 * Constraint:
	 *     (variables+=VariableDeclaration variables+=VariableDeclaration* type=Type value=Expression?)
	 */
	protected void sequence_VariablesDeclaration(ISerializationContext context, VariablesDeclaration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns WaitStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns WaitStatement
	 *     StatementChoice returns WaitStatement
	 *     StatementChoice.StatementChoice_1_0 returns WaitStatement
	 *     StatementSequence returns WaitStatement
	 *     StatementSequence.StatementSequence_1_0 returns WaitStatement
	 *     Statement returns WaitStatement
	 *     WaitStatement returns WaitStatement
	 *
	 * Constraint:
	 *     (left=LowerBound right=UpperBound)
	 */
	protected void sequence_WaitStatement(ISerializationContext context, WaitStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getWaitStatement_Left()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getWaitStatement_Left()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getWaitStatement_Right()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getWaitStatement_Right()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getWaitStatementAccess().getLeftLowerBoundParserRuleCall_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getWaitStatementAccess().getRightUpperBoundParserRuleCall_3_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     UnlessStatement returns WhileStatement
	 *     UnlessStatement.UnlessStatement_1_0 returns WhileStatement
	 *     StatementChoice returns WhileStatement
	 *     StatementChoice.StatementChoice_1_0 returns WhileStatement
	 *     StatementSequence returns WhileStatement
	 *     StatementSequence.StatementSequence_1_0 returns WhileStatement
	 *     Statement returns WhileStatement
	 *     WhileStatement returns WhileStatement
	 *
	 * Constraint:
	 *     (condition=Expression body=StatementSequence)
	 */
	protected void sequence_WhileStatement(ISerializationContext context, WhileStatement semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getWhileStatement_Condition()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getWhileStatement_Condition()));
			if (transientValues.isValueTransient(semanticObject, FiacrePackage.eINSTANCE.getWhileStatement_Body()) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FiacrePackage.eINSTANCE.getWhileStatement_Body()));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_1_0(), semanticObject.getCondition());
		feeder.accept(grammarAccess.getWhileStatementAccess().getBodyStatementSequenceParserRuleCall_3_0(), semanticObject.getBody());
		feeder.finish();
	}
	
	
}
