/*
 * generated by Xtext 2.10.0
 */
grammar InternalFiacre;

options {
	superClass=AbstractInternalContentAssistParser;
	backtrack=true;
}

@lexer::header {
package fr.irit.fiacre.xtext.ide.contentassist.antlr.internal;

// Hack: Use our own Lexer superclass by means of import. 
// Currently there is no other way to specify the superclass for the lexer.
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
}

@parser::header {
package fr.irit.fiacre.xtext.ide.contentassist.antlr.internal;

import java.io.InputStream;
import org.eclipse.xtext.*;
import org.eclipse.xtext.parser.*;
import org.eclipse.xtext.parser.impl.*;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.parser.antlr.XtextTokenStream;
import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
import fr.irit.fiacre.xtext.services.FiacreGrammarAccess;

}
@parser::members {
	private FiacreGrammarAccess grammarAccess;

	public void setGrammarAccess(FiacreGrammarAccess grammarAccess) {
		this.grammarAccess = grammarAccess;
	}

	@Override
	protected Grammar getGrammar() {
		return grammarAccess.getGrammar();
	}

	@Override
	protected String getValueForTokenName(String tokenName) {
		return tokenName;
	}
}

// Entry rule entryRuleModel
entryRuleModel
:
{ before(grammarAccess.getModelRule()); }
	 ruleModel
{ after(grammarAccess.getModelRule()); } 
	 EOF 
;

// Rule Model
ruleModel 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getModelAccess().getGroup()); }
		(rule__Model__Group__0)
		{ after(grammarAccess.getModelAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleRoot
entryRuleRoot
:
{ before(grammarAccess.getRootRule()); }
	 ruleRoot
{ after(grammarAccess.getRootRule()); } 
	 EOF 
;

// Rule Root
ruleRoot 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRootAccess().getGroup()); }
		(rule__Root__Group__0)
		{ after(grammarAccess.getRootAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleImportDeclaration
entryRuleImportDeclaration
:
{ before(grammarAccess.getImportDeclarationRule()); }
	 ruleImportDeclaration
{ after(grammarAccess.getImportDeclarationRule()); } 
	 EOF 
;

// Rule ImportDeclaration
ruleImportDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getImportDeclarationAccess().getGroup()); }
		(rule__ImportDeclaration__Group__0)
		{ after(grammarAccess.getImportDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDeclaration
entryRuleDeclaration
:
{ before(grammarAccess.getDeclarationRule()); }
	 ruleDeclaration
{ after(grammarAccess.getDeclarationRule()); } 
	 EOF 
;

// Rule Declaration
ruleDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDeclarationAccess().getAlternatives()); }
		(rule__Declaration__Alternatives)
		{ after(grammarAccess.getDeclarationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleParameterizedDeclaration
entryRuleParameterizedDeclaration
:
{ before(grammarAccess.getParameterizedDeclarationRule()); }
	 ruleParameterizedDeclaration
{ after(grammarAccess.getParameterizedDeclarationRule()); } 
	 EOF 
;

// Rule ParameterizedDeclaration
ruleParameterizedDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getParameterizedDeclarationAccess().getAlternatives()); }
		(rule__ParameterizedDeclaration__Alternatives)
		{ after(grammarAccess.getParameterizedDeclarationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleFunctionDeclaration
entryRuleFunctionDeclaration
:
{ before(grammarAccess.getFunctionDeclarationRule()); }
	 ruleFunctionDeclaration
{ after(grammarAccess.getFunctionDeclarationRule()); } 
	 EOF 
;

// Rule FunctionDeclaration
ruleFunctionDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getFunctionDeclarationAccess().getGroup()); }
		(rule__FunctionDeclaration__Group__0)
		{ after(grammarAccess.getFunctionDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTypeDeclaration
entryRuleTypeDeclaration
:
{ before(grammarAccess.getTypeDeclarationRule()); }
	 ruleTypeDeclaration
{ after(grammarAccess.getTypeDeclarationRule()); } 
	 EOF 
;

// Rule TypeDeclaration
ruleTypeDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTypeDeclarationAccess().getGroup()); }
		(rule__TypeDeclaration__Group__0)
		{ after(grammarAccess.getTypeDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleChannelDeclaration
entryRuleChannelDeclaration
:
{ before(grammarAccess.getChannelDeclarationRule()); }
	 ruleChannelDeclaration
{ after(grammarAccess.getChannelDeclarationRule()); } 
	 EOF 
;

// Rule ChannelDeclaration
ruleChannelDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getChannelDeclarationAccess().getGroup()); }
		(rule__ChannelDeclaration__Group__0)
		{ after(grammarAccess.getChannelDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleChannelType
entryRuleChannelType
:
{ before(grammarAccess.getChannelTypeRule()); }
	 ruleChannelType
{ after(grammarAccess.getChannelTypeRule()); } 
	 EOF 
;

// Rule ChannelType
ruleChannelType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getChannelTypeAccess().getGroup()); }
		(rule__ChannelType__Group__0)
		{ after(grammarAccess.getChannelTypeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleType
entryRuleType
:
{ before(grammarAccess.getTypeRule()); }
	 ruleType
{ after(grammarAccess.getTypeRule()); } 
	 EOF 
;

// Rule Type
ruleType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTypeAccess().getAlternatives()); }
		(rule__Type__Alternatives)
		{ after(grammarAccess.getTypeAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTupleType
entryRuleTupleType
:
{ before(grammarAccess.getTupleTypeRule()); }
	 ruleTupleType
{ after(grammarAccess.getTupleTypeRule()); } 
	 EOF 
;

// Rule TupleType
ruleTupleType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTupleTypeAccess().getGroup()); }
		(rule__TupleType__Group__0)
		{ after(grammarAccess.getTupleTypeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleBasicType
entryRuleBasicType
:
{ before(grammarAccess.getBasicTypeRule()); }
	 ruleBasicType
{ after(grammarAccess.getBasicTypeRule()); } 
	 EOF 
;

// Rule BasicType
ruleBasicType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getBasicTypeAccess().getAlternatives()); }
		(rule__BasicType__Alternatives)
		{ after(grammarAccess.getBasicTypeAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleRangeType
entryRuleRangeType
:
{ before(grammarAccess.getRangeTypeRule()); }
	 ruleRangeType
{ after(grammarAccess.getRangeTypeRule()); } 
	 EOF 
;

// Rule RangeType
ruleRangeType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRangeTypeAccess().getGroup()); }
		(rule__RangeType__Group__0)
		{ after(grammarAccess.getRangeTypeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUnionType
entryRuleUnionType
:
{ before(grammarAccess.getUnionTypeRule()); }
	 ruleUnionType
{ after(grammarAccess.getUnionTypeRule()); } 
	 EOF 
;

// Rule UnionType
ruleUnionType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnionTypeAccess().getGroup()); }
		(rule__UnionType__Group__0)
		{ after(grammarAccess.getUnionTypeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUnionTags
entryRuleUnionTags
:
{ before(grammarAccess.getUnionTagsRule()); }
	 ruleUnionTags
{ after(grammarAccess.getUnionTagsRule()); } 
	 EOF 
;

// Rule UnionTags
ruleUnionTags 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnionTagsAccess().getGroup()); }
		(rule__UnionTags__Group__0)
		{ after(grammarAccess.getUnionTagsAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUnionTagDeclaration
entryRuleUnionTagDeclaration
:
{ before(grammarAccess.getUnionTagDeclarationRule()); }
	 ruleUnionTagDeclaration
{ after(grammarAccess.getUnionTagDeclarationRule()); } 
	 EOF 
;

// Rule UnionTagDeclaration
ruleUnionTagDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnionTagDeclarationAccess().getNameAssignment()); }
		(rule__UnionTagDeclaration__NameAssignment)
		{ after(grammarAccess.getUnionTagDeclarationAccess().getNameAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleRecordType
entryRuleRecordType
:
{ before(grammarAccess.getRecordTypeRule()); }
	 ruleRecordType
{ after(grammarAccess.getRecordTypeRule()); } 
	 EOF 
;

// Rule RecordType
ruleRecordType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRecordTypeAccess().getGroup()); }
		(rule__RecordType__Group__0)
		{ after(grammarAccess.getRecordTypeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleRecordFields
entryRuleRecordFields
:
{ before(grammarAccess.getRecordFieldsRule()); }
	 ruleRecordFields
{ after(grammarAccess.getRecordFieldsRule()); } 
	 EOF 
;

// Rule RecordFields
ruleRecordFields 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRecordFieldsAccess().getGroup()); }
		(rule__RecordFields__Group__0)
		{ after(grammarAccess.getRecordFieldsAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleRecordFieldDeclaration
entryRuleRecordFieldDeclaration
:
{ before(grammarAccess.getRecordFieldDeclarationRule()); }
	 ruleRecordFieldDeclaration
{ after(grammarAccess.getRecordFieldDeclarationRule()); } 
	 EOF 
;

// Rule RecordFieldDeclaration
ruleRecordFieldDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRecordFieldDeclarationAccess().getNameAssignment()); }
		(rule__RecordFieldDeclaration__NameAssignment)
		{ after(grammarAccess.getRecordFieldDeclarationAccess().getNameAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleQueueType
entryRuleQueueType
:
{ before(grammarAccess.getQueueTypeRule()); }
	 ruleQueueType
{ after(grammarAccess.getQueueTypeRule()); } 
	 EOF 
;

// Rule QueueType
ruleQueueType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getQueueTypeAccess().getGroup()); }
		(rule__QueueType__Group__0)
		{ after(grammarAccess.getQueueTypeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleArrayType
entryRuleArrayType
:
{ before(grammarAccess.getArrayTypeRule()); }
	 ruleArrayType
{ after(grammarAccess.getArrayTypeRule()); } 
	 EOF 
;

// Rule ArrayType
ruleArrayType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getArrayTypeAccess().getGroup()); }
		(rule__ArrayType__Group__0)
		{ after(grammarAccess.getArrayTypeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleReferencedType
entryRuleReferencedType
:
{ before(grammarAccess.getReferencedTypeRule()); }
	 ruleReferencedType
{ after(grammarAccess.getReferencedTypeRule()); } 
	 EOF 
;

// Rule ReferencedType
ruleReferencedType 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getReferencedTypeAccess().getTypeAssignment()); }
		(rule__ReferencedType__TypeAssignment)
		{ after(grammarAccess.getReferencedTypeAccess().getTypeAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleConstantDeclaration
entryRuleConstantDeclaration
:
{ before(grammarAccess.getConstantDeclarationRule()); }
	 ruleConstantDeclaration
{ after(grammarAccess.getConstantDeclarationRule()); } 
	 EOF 
;

// Rule ConstantDeclaration
ruleConstantDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getConstantDeclarationAccess().getGroup()); }
		(rule__ConstantDeclaration__Group__0)
		{ after(grammarAccess.getConstantDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleProcessDeclaration
entryRuleProcessDeclaration
:
{ before(grammarAccess.getProcessDeclarationRule()); }
	 ruleProcessDeclaration
{ after(grammarAccess.getProcessDeclarationRule()); } 
	 EOF 
;

// Rule ProcessDeclaration
ruleProcessDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getGroup()); }
		(rule__ProcessDeclaration__Group__0)
		{ after(grammarAccess.getProcessDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleStateDeclaration
entryRuleStateDeclaration
:
{ before(grammarAccess.getStateDeclarationRule()); }
	 ruleStateDeclaration
{ after(grammarAccess.getStateDeclarationRule()); } 
	 EOF 
;

// Rule StateDeclaration
ruleStateDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getStateDeclarationAccess().getNameAssignment()); }
		(rule__StateDeclaration__NameAssignment)
		{ after(grammarAccess.getStateDeclarationAccess().getNameAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTransitionSource
entryRuleTransitionSource
:
{ before(grammarAccess.getTransitionSourceRule()); }
	 ruleTransitionSource
{ after(grammarAccess.getTransitionSourceRule()); } 
	 EOF 
;

// Rule TransitionSource
ruleTransitionSource 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTransitionSourceAccess().getGroup()); }
		(rule__TransitionSource__Group__0)
		{ after(grammarAccess.getTransitionSourceAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTransition
entryRuleTransition
:
{ before(grammarAccess.getTransitionRule()); }
	 ruleTransition
{ after(grammarAccess.getTransitionRule()); } 
	 EOF 
;

// Rule Transition
ruleTransition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTransitionAccess().getGroup()); }
		(rule__Transition__Group__0)
		{ after(grammarAccess.getTransitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleComponentDeclaration
entryRuleComponentDeclaration
:
{ before(grammarAccess.getComponentDeclarationRule()); }
	 ruleComponentDeclaration
{ after(grammarAccess.getComponentDeclarationRule()); } 
	 EOF 
;

// Rule ComponentDeclaration
ruleComponentDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getGroup()); }
		(rule__ComponentDeclaration__Group__0)
		{ after(grammarAccess.getComponentDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePortsDeclaration
entryRulePortsDeclaration
:
{ before(grammarAccess.getPortsDeclarationRule()); }
	 rulePortsDeclaration
{ after(grammarAccess.getPortsDeclarationRule()); } 
	 EOF 
;

// Rule PortsDeclaration
rulePortsDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPortsDeclarationAccess().getGroup()); }
		(rule__PortsDeclaration__Group__0)
		{ after(grammarAccess.getPortsDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePortDeclaration
entryRulePortDeclaration
:
{ before(grammarAccess.getPortDeclarationRule()); }
	 rulePortDeclaration
{ after(grammarAccess.getPortDeclarationRule()); } 
	 EOF 
;

// Rule PortDeclaration
rulePortDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPortDeclarationAccess().getNameAssignment()); }
		(rule__PortDeclaration__NameAssignment)
		{ after(grammarAccess.getPortDeclarationAccess().getNameAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLocalPortsDeclaration
entryRuleLocalPortsDeclaration
:
{ before(grammarAccess.getLocalPortsDeclarationRule()); }
	 ruleLocalPortsDeclaration
{ after(grammarAccess.getLocalPortsDeclarationRule()); } 
	 EOF 
;

// Rule LocalPortsDeclaration
ruleLocalPortsDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLocalPortsDeclarationAccess().getGroup()); }
		(rule__LocalPortsDeclaration__Group__0)
		{ after(grammarAccess.getLocalPortsDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleParametersDeclaration
entryRuleParametersDeclaration
:
{ before(grammarAccess.getParametersDeclarationRule()); }
	 ruleParametersDeclaration
{ after(grammarAccess.getParametersDeclarationRule()); } 
	 EOF 
;

// Rule ParametersDeclaration
ruleParametersDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getParametersDeclarationAccess().getGroup()); }
		(rule__ParametersDeclaration__Group__0)
		{ after(grammarAccess.getParametersDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleParameterDeclaration
entryRuleParameterDeclaration
:
{ before(grammarAccess.getParameterDeclarationRule()); }
	 ruleParameterDeclaration
{ after(grammarAccess.getParameterDeclarationRule()); } 
	 EOF 
;

// Rule ParameterDeclaration
ruleParameterDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getParameterDeclarationAccess().getGroup()); }
		(rule__ParameterDeclaration__Group__0)
		{ after(grammarAccess.getParameterDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleVariablesDeclaration
entryRuleVariablesDeclaration
:
{ before(grammarAccess.getVariablesDeclarationRule()); }
	 ruleVariablesDeclaration
{ after(grammarAccess.getVariablesDeclarationRule()); } 
	 EOF 
;

// Rule VariablesDeclaration
ruleVariablesDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getVariablesDeclarationAccess().getGroup()); }
		(rule__VariablesDeclaration__Group__0)
		{ after(grammarAccess.getVariablesDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleVariableDeclaration
entryRuleVariableDeclaration
:
{ before(grammarAccess.getVariableDeclarationRule()); }
	 ruleVariableDeclaration
{ after(grammarAccess.getVariableDeclarationRule()); } 
	 EOF 
;

// Rule VariableDeclaration
ruleVariableDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getVariableDeclarationAccess().getNameAssignment()); }
		(rule__VariableDeclaration__NameAssignment)
		{ after(grammarAccess.getVariableDeclarationAccess().getNameAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePriorityDeclaration
entryRulePriorityDeclaration
:
{ before(grammarAccess.getPriorityDeclarationRule()); }
	 rulePriorityDeclaration
{ after(grammarAccess.getPriorityDeclarationRule()); } 
	 EOF 
;

// Rule PriorityDeclaration
rulePriorityDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPriorityDeclarationAccess().getGroup()); }
		(rule__PriorityDeclaration__Group__0)
		{ after(grammarAccess.getPriorityDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePriorityGroup
entryRulePriorityGroup
:
{ before(grammarAccess.getPriorityGroupRule()); }
	 rulePriorityGroup
{ after(grammarAccess.getPriorityGroupRule()); } 
	 EOF 
;

// Rule PriorityGroup
rulePriorityGroup 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPriorityGroupAccess().getGroup()); }
		(rule__PriorityGroup__Group__0)
		{ after(grammarAccess.getPriorityGroupAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUnlessStatement
entryRuleUnlessStatement
:
{ before(grammarAccess.getUnlessStatementRule()); }
	 ruleUnlessStatement
{ after(grammarAccess.getUnlessStatementRule()); } 
	 EOF 
;

// Rule UnlessStatement
ruleUnlessStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnlessStatementAccess().getGroup()); }
		(rule__UnlessStatement__Group__0)
		{ after(grammarAccess.getUnlessStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleStatementChoice
entryRuleStatementChoice
:
{ before(grammarAccess.getStatementChoiceRule()); }
	 ruleStatementChoice
{ after(grammarAccess.getStatementChoiceRule()); } 
	 EOF 
;

// Rule StatementChoice
ruleStatementChoice 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getStatementChoiceAccess().getGroup()); }
		(rule__StatementChoice__Group__0)
		{ after(grammarAccess.getStatementChoiceAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleStatementSequence
entryRuleStatementSequence
:
{ before(grammarAccess.getStatementSequenceRule()); }
	 ruleStatementSequence
{ after(grammarAccess.getStatementSequenceRule()); } 
	 EOF 
;

// Rule StatementSequence
ruleStatementSequence 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getStatementSequenceAccess().getGroup()); }
		(rule__StatementSequence__Group__0)
		{ after(grammarAccess.getStatementSequenceAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleStatement
entryRuleStatement
:
{ before(grammarAccess.getStatementRule()); }
	 ruleStatement
{ after(grammarAccess.getStatementRule()); } 
	 EOF 
;

// Rule Statement
ruleStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getStatementAccess().getAlternatives()); }
		(rule__Statement__Alternatives)
		{ after(grammarAccess.getStatementAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleBlockStatement
entryRuleBlockStatement
:
{ before(grammarAccess.getBlockStatementRule()); }
	 ruleBlockStatement
{ after(grammarAccess.getBlockStatementRule()); } 
	 EOF 
;

// Rule BlockStatement
ruleBlockStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getBlockStatementAccess().getGroup()); }
		(rule__BlockStatement__Group__0)
		{ after(grammarAccess.getBlockStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleReturnStatement
entryRuleReturnStatement
:
{ before(grammarAccess.getReturnStatementRule()); }
	 ruleReturnStatement
{ after(grammarAccess.getReturnStatementRule()); } 
	 EOF 
;

// Rule ReturnStatement
ruleReturnStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getReturnStatementAccess().getGroup()); }
		(rule__ReturnStatement__Group__0)
		{ after(grammarAccess.getReturnStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleNullStatement
entryRuleNullStatement
:
{ before(grammarAccess.getNullStatementRule()); }
	 ruleNullStatement
{ after(grammarAccess.getNullStatementRule()); } 
	 EOF 
;

// Rule NullStatement
ruleNullStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNullStatementAccess().getGroup()); }
		(rule__NullStatement__Group__0)
		{ after(grammarAccess.getNullStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTaggedStatement
entryRuleTaggedStatement
:
{ before(grammarAccess.getTaggedStatementRule()); }
	 ruleTaggedStatement
{ after(grammarAccess.getTaggedStatementRule()); } 
	 EOF 
;

// Rule TaggedStatement
ruleTaggedStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTaggedStatementAccess().getGroup()); }
		(rule__TaggedStatement__Group__0)
		{ after(grammarAccess.getTaggedStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePatternStatement
entryRulePatternStatement
:
{ before(grammarAccess.getPatternStatementRule()); }
	 rulePatternStatement
{ after(grammarAccess.getPatternStatementRule()); } 
	 EOF 
;

// Rule PatternStatement
rulePatternStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPatternStatementAccess().getGroup()); }
		(rule__PatternStatement__Group__0)
		{ after(grammarAccess.getPatternStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePattern
entryRulePattern
:
{ before(grammarAccess.getPatternRule()); }
	 rulePattern
{ after(grammarAccess.getPatternRule()); } 
	 EOF 
;

// Rule Pattern
rulePattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPatternAccess().getAlternatives()); }
		(rule__Pattern__Alternatives)
		{ after(grammarAccess.getPatternAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAnyPattern
entryRuleAnyPattern
:
{ before(grammarAccess.getAnyPatternRule()); }
	 ruleAnyPattern
{ after(grammarAccess.getAnyPatternRule()); } 
	 EOF 
;

// Rule AnyPattern
ruleAnyPattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAnyPatternAccess().getGroup()); }
		(rule__AnyPattern__Group__0)
		{ after(grammarAccess.getAnyPatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleConstantPattern
entryRuleConstantPattern
:
{ before(grammarAccess.getConstantPatternRule()); }
	 ruleConstantPattern
{ after(grammarAccess.getConstantPatternRule()); } 
	 EOF 
;

// Rule ConstantPattern
ruleConstantPattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getConstantPatternAccess().getValueAssignment()); }
		(rule__ConstantPattern__ValueAssignment)
		{ after(grammarAccess.getConstantPatternAccess().getValueAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleIntegerPattern
entryRuleIntegerPattern
:
{ before(grammarAccess.getIntegerPatternRule()); }
	 ruleIntegerPattern
{ after(grammarAccess.getIntegerPatternRule()); } 
	 EOF 
;

// Rule IntegerPattern
ruleIntegerPattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getIntegerPatternAccess().getGroup()); }
		(rule__IntegerPattern__Group__0)
		{ after(grammarAccess.getIntegerPatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleIdentifierPattern
entryRuleIdentifierPattern
:
{ before(grammarAccess.getIdentifierPatternRule()); }
	 ruleIdentifierPattern
{ after(grammarAccess.getIdentifierPatternRule()); } 
	 EOF 
;

// Rule IdentifierPattern
ruleIdentifierPattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getAlternatives()); }
		(rule__IdentifierPattern__Alternatives)
		{ after(grammarAccess.getIdentifierPatternAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleConditionalStatement
entryRuleConditionalStatement
:
{ before(grammarAccess.getConditionalStatementRule()); }
	 ruleConditionalStatement
{ after(grammarAccess.getConditionalStatementRule()); } 
	 EOF 
;

// Rule ConditionalStatement
ruleConditionalStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getConditionalStatementAccess().getGroup()); }
		(rule__ConditionalStatement__Group__0)
		{ after(grammarAccess.getConditionalStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExtendedConditionalStatement
entryRuleExtendedConditionalStatement
:
{ before(grammarAccess.getExtendedConditionalStatementRule()); }
	 ruleExtendedConditionalStatement
{ after(grammarAccess.getExtendedConditionalStatementRule()); } 
	 EOF 
;

// Rule ExtendedConditionalStatement
ruleExtendedConditionalStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExtendedConditionalStatementAccess().getGroup()); }
		(rule__ExtendedConditionalStatement__Group__0)
		{ after(grammarAccess.getExtendedConditionalStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleSelectStatement
entryRuleSelectStatement
:
{ before(grammarAccess.getSelectStatementRule()); }
	 ruleSelectStatement
{ after(grammarAccess.getSelectStatementRule()); } 
	 EOF 
;

// Rule SelectStatement
ruleSelectStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getSelectStatementAccess().getGroup()); }
		(rule__SelectStatement__Group__0)
		{ after(grammarAccess.getSelectStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleWhileStatement
entryRuleWhileStatement
:
{ before(grammarAccess.getWhileStatementRule()); }
	 ruleWhileStatement
{ after(grammarAccess.getWhileStatementRule()); } 
	 EOF 
;

// Rule WhileStatement
ruleWhileStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getWhileStatementAccess().getGroup()); }
		(rule__WhileStatement__Group__0)
		{ after(grammarAccess.getWhileStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleForeachStatement
entryRuleForeachStatement
:
{ before(grammarAccess.getForeachStatementRule()); }
	 ruleForeachStatement
{ after(grammarAccess.getForeachStatementRule()); } 
	 EOF 
;

// Rule ForeachStatement
ruleForeachStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getForeachStatementAccess().getGroup()); }
		(rule__ForeachStatement__Group__0)
		{ after(grammarAccess.getForeachStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleToStatement
entryRuleToStatement
:
{ before(grammarAccess.getToStatementRule()); }
	 ruleToStatement
{ after(grammarAccess.getToStatementRule()); } 
	 EOF 
;

// Rule ToStatement
ruleToStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getToStatementAccess().getGroup()); }
		(rule__ToStatement__Group__0)
		{ after(grammarAccess.getToStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleCaseStatement
entryRuleCaseStatement
:
{ before(grammarAccess.getCaseStatementRule()); }
	 ruleCaseStatement
{ after(grammarAccess.getCaseStatementRule()); } 
	 EOF 
;

// Rule CaseStatement
ruleCaseStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getCaseStatementAccess().getGroup()); }
		(rule__CaseStatement__Group__0)
		{ after(grammarAccess.getCaseStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLoopStatement
entryRuleLoopStatement
:
{ before(grammarAccess.getLoopStatementRule()); }
	 ruleLoopStatement
{ after(grammarAccess.getLoopStatementRule()); } 
	 EOF 
;

// Rule LoopStatement
ruleLoopStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLoopStatementAccess().getGroup()); }
		(rule__LoopStatement__Group__0)
		{ after(grammarAccess.getLoopStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleOnStatement
entryRuleOnStatement
:
{ before(grammarAccess.getOnStatementRule()); }
	 ruleOnStatement
{ after(grammarAccess.getOnStatementRule()); } 
	 EOF 
;

// Rule OnStatement
ruleOnStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getOnStatementAccess().getGroup()); }
		(rule__OnStatement__Group__0)
		{ after(grammarAccess.getOnStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleWaitStatement
entryRuleWaitStatement
:
{ before(grammarAccess.getWaitStatementRule()); }
	 ruleWaitStatement
{ after(grammarAccess.getWaitStatementRule()); } 
	 EOF 
;

// Rule WaitStatement
ruleWaitStatement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getWaitStatementAccess().getGroup()); }
		(rule__WaitStatement__Group__0)
		{ after(grammarAccess.getWaitStatementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleComposition
entryRuleComposition
:
{ before(grammarAccess.getCompositionRule()); }
	 ruleComposition
{ after(grammarAccess.getCompositionRule()); } 
	 EOF 
;

// Rule Composition
ruleComposition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getCompositionAccess().getGroup()); }
		(rule__Composition__Group__0)
		{ after(grammarAccess.getCompositionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleBlock
entryRuleBlock
:
{ before(grammarAccess.getBlockRule()); }
	 ruleBlock
{ after(grammarAccess.getBlockRule()); } 
	 EOF 
;

// Rule Block
ruleBlock 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getBlockAccess().getAlternatives()); }
		(rule__Block__Alternatives)
		{ after(grammarAccess.getBlockAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleCompositeBlock
entryRuleCompositeBlock
:
{ before(grammarAccess.getCompositeBlockRule()); }
	 ruleCompositeBlock
{ after(grammarAccess.getCompositeBlockRule()); } 
	 EOF 
;

// Rule CompositeBlock
ruleCompositeBlock 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getCompositeBlockAccess().getGroup()); }
		(rule__CompositeBlock__Group__0)
		{ after(grammarAccess.getCompositeBlockAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleInstanceDeclaration
entryRuleInstanceDeclaration
:
{ before(grammarAccess.getInstanceDeclarationRule()); }
	 ruleInstanceDeclaration
{ after(grammarAccess.getInstanceDeclarationRule()); } 
	 EOF 
;

// Rule InstanceDeclaration
ruleInstanceDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getInstanceDeclarationAccess().getGroup()); }
		(rule__InstanceDeclaration__Group__0)
		{ after(grammarAccess.getInstanceDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePortSet
entryRulePortSet
:
{ before(grammarAccess.getPortSetRule()); }
	 rulePortSet
{ after(grammarAccess.getPortSetRule()); } 
	 EOF 
;

// Rule PortSet
rulePortSet 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPortSetAccess().getAlternatives()); }
		(rule__PortSet__Alternatives)
		{ after(grammarAccess.getPortSetAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleComponentInstance
entryRuleComponentInstance
:
{ before(grammarAccess.getComponentInstanceRule()); }
	 ruleComponentInstance
{ after(grammarAccess.getComponentInstanceRule()); } 
	 EOF 
;

// Rule ComponentInstance
ruleComponentInstance 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getComponentInstanceAccess().getGroup()); }
		(rule__ComponentInstance__Group__0)
		{ after(grammarAccess.getComponentInstanceAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExpression
entryRuleExpression
:
{ before(grammarAccess.getExpressionRule()); }
	 ruleExpression
{ after(grammarAccess.getExpressionRule()); } 
	 EOF 
;

// Rule Expression
ruleExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExpressionAccess().getQuantifiedExpressionParserRuleCall()); }
		ruleQuantifiedExpression
		{ after(grammarAccess.getExpressionAccess().getQuantifiedExpressionParserRuleCall()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleQuantifiedExpression
entryRuleQuantifiedExpression
:
{ before(grammarAccess.getQuantifiedExpressionRule()); }
	 ruleQuantifiedExpression
{ after(grammarAccess.getQuantifiedExpressionRule()); } 
	 EOF 
;

// Rule QuantifiedExpression
ruleQuantifiedExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getAlternatives()); }
		(rule__QuantifiedExpression__Alternatives)
		{ after(grammarAccess.getQuantifiedExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleConditional
entryRuleConditional
:
{ before(grammarAccess.getConditionalRule()); }
	 ruleConditional
{ after(grammarAccess.getConditionalRule()); } 
	 EOF 
;

// Rule Conditional
ruleConditional 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getConditionalAccess().getGroup()); }
		(rule__Conditional__Group__0)
		{ after(grammarAccess.getConditionalAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDisjunction
entryRuleDisjunction
:
{ before(grammarAccess.getDisjunctionRule()); }
	 ruleDisjunction
{ after(grammarAccess.getDisjunctionRule()); } 
	 EOF 
;

// Rule Disjunction
ruleDisjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDisjunctionAccess().getGroup()); }
		(rule__Disjunction__Group__0)
		{ after(grammarAccess.getDisjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleImplication
entryRuleImplication
:
{ before(grammarAccess.getImplicationRule()); }
	 ruleImplication
{ after(grammarAccess.getImplicationRule()); } 
	 EOF 
;

// Rule Implication
ruleImplication 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getImplicationAccess().getGroup()); }
		(rule__Implication__Group__0)
		{ after(grammarAccess.getImplicationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleConjunction
entryRuleConjunction
:
{ before(grammarAccess.getConjunctionRule()); }
	 ruleConjunction
{ after(grammarAccess.getConjunctionRule()); } 
	 EOF 
;

// Rule Conjunction
ruleConjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getConjunctionAccess().getGroup()); }
		(rule__Conjunction__Group__0)
		{ after(grammarAccess.getConjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleComparison
entryRuleComparison
:
{ before(grammarAccess.getComparisonRule()); }
	 ruleComparison
{ after(grammarAccess.getComparisonRule()); } 
	 EOF 
;

// Rule Comparison
ruleComparison 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getComparisonAccess().getGroup()); }
		(rule__Comparison__Group__0)
		{ after(grammarAccess.getComparisonAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAddition
entryRuleAddition
:
{ before(grammarAccess.getAdditionRule()); }
	 ruleAddition
{ after(grammarAccess.getAdditionRule()); } 
	 EOF 
;

// Rule Addition
ruleAddition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAdditionAccess().getGroup()); }
		(rule__Addition__Group__0)
		{ after(grammarAccess.getAdditionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleSubstraction
entryRuleSubstraction
:
{ before(grammarAccess.getSubstractionRule()); }
	 ruleSubstraction
{ after(grammarAccess.getSubstractionRule()); } 
	 EOF 
;

// Rule Substraction
ruleSubstraction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getSubstractionAccess().getGroup()); }
		(rule__Substraction__Group__0)
		{ after(grammarAccess.getSubstractionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleMultiplication
entryRuleMultiplication
:
{ before(grammarAccess.getMultiplicationRule()); }
	 ruleMultiplication
{ after(grammarAccess.getMultiplicationRule()); } 
	 EOF 
;

// Rule Multiplication
ruleMultiplication 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getMultiplicationAccess().getGroup()); }
		(rule__Multiplication__Group__0)
		{ after(grammarAccess.getMultiplicationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDivision
entryRuleDivision
:
{ before(grammarAccess.getDivisionRule()); }
	 ruleDivision
{ after(grammarAccess.getDivisionRule()); } 
	 EOF 
;

// Rule Division
ruleDivision 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDivisionAccess().getGroup()); }
		(rule__Division__Group__0)
		{ after(grammarAccess.getDivisionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleModulo
entryRuleModulo
:
{ before(grammarAccess.getModuloRule()); }
	 ruleModulo
{ after(grammarAccess.getModuloRule()); } 
	 EOF 
;

// Rule Modulo
ruleModulo 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getModuloAccess().getGroup()); }
		(rule__Modulo__Group__0)
		{ after(grammarAccess.getModuloAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUnaryExpression
entryRuleUnaryExpression
:
{ before(grammarAccess.getUnaryExpressionRule()); }
	 ruleUnaryExpression
{ after(grammarAccess.getUnaryExpressionRule()); } 
	 EOF 
;

// Rule UnaryExpression
ruleUnaryExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getAlternatives()); }
		(rule__UnaryExpression__Alternatives)
		{ after(grammarAccess.getUnaryExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleProjection
entryRuleProjection
:
{ before(grammarAccess.getProjectionRule()); }
	 ruleProjection
{ after(grammarAccess.getProjectionRule()); } 
	 EOF 
;

// Rule Projection
ruleProjection 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getProjectionAccess().getGroup()); }
		(rule__Projection__Group__0)
		{ after(grammarAccess.getProjectionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAtomicExpression
entryRuleAtomicExpression
:
{ before(grammarAccess.getAtomicExpressionRule()); }
	 ruleAtomicExpression
{ after(grammarAccess.getAtomicExpressionRule()); } 
	 EOF 
;

// Rule AtomicExpression
ruleAtomicExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getAlternatives()); }
		(rule__AtomicExpression__Alternatives)
		{ after(grammarAccess.getAtomicExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleReferenceExpression
entryRuleReferenceExpression
:
{ before(grammarAccess.getReferenceExpressionRule()); }
	 ruleReferenceExpression
{ after(grammarAccess.getReferenceExpressionRule()); } 
	 EOF 
;

// Rule ReferenceExpression
ruleReferenceExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getReferenceExpressionAccess().getGroup()); }
		(rule__ReferenceExpression__Group__0)
		{ after(grammarAccess.getReferenceExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleIdentifierExpression
entryRuleIdentifierExpression
:
{ before(grammarAccess.getIdentifierExpressionRule()); }
	 ruleIdentifierExpression
{ after(grammarAccess.getIdentifierExpressionRule()); } 
	 EOF 
;

// Rule IdentifierExpression
ruleIdentifierExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getAlternatives()); }
		(rule__IdentifierExpression__Alternatives)
		{ after(grammarAccess.getIdentifierExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleRecordExpression
entryRuleRecordExpression
:
{ before(grammarAccess.getRecordExpressionRule()); }
	 ruleRecordExpression
{ after(grammarAccess.getRecordExpressionRule()); } 
	 EOF 
;

// Rule RecordExpression
ruleRecordExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRecordExpressionAccess().getGroup()); }
		(rule__RecordExpression__Group__0)
		{ after(grammarAccess.getRecordExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleFieldExpression
entryRuleFieldExpression
:
{ before(grammarAccess.getFieldExpressionRule()); }
	 ruleFieldExpression
{ after(grammarAccess.getFieldExpressionRule()); } 
	 EOF 
;

// Rule FieldExpression
ruleFieldExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getFieldExpressionAccess().getGroup()); }
		(rule__FieldExpression__Group__0)
		{ after(grammarAccess.getFieldExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleArrayExpression
entryRuleArrayExpression
:
{ before(grammarAccess.getArrayExpressionRule()); }
	 ruleArrayExpression
{ after(grammarAccess.getArrayExpressionRule()); } 
	 EOF 
;

// Rule ArrayExpression
ruleArrayExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getArrayExpressionAccess().getGroup()); }
		(rule__ArrayExpression__Group__0)
		{ after(grammarAccess.getArrayExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleQueueExpression
entryRuleQueueExpression
:
{ before(grammarAccess.getQueueExpressionRule()); }
	 ruleQueueExpression
{ after(grammarAccess.getQueueExpressionRule()); } 
	 EOF 
;

// Rule QueueExpression
ruleQueueExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getQueueExpressionAccess().getGroup()); }
		(rule__QueueExpression__Group__0)
		{ after(grammarAccess.getQueueExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleEnqueueExpression
entryRuleEnqueueExpression
:
{ before(grammarAccess.getEnqueueExpressionRule()); }
	 ruleEnqueueExpression
{ after(grammarAccess.getEnqueueExpressionRule()); } 
	 EOF 
;

// Rule EnqueueExpression
ruleEnqueueExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getEnqueueExpressionAccess().getGroup()); }
		(rule__EnqueueExpression__Group__0)
		{ after(grammarAccess.getEnqueueExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAppendExpression
entryRuleAppendExpression
:
{ before(grammarAccess.getAppendExpressionRule()); }
	 ruleAppendExpression
{ after(grammarAccess.getAppendExpressionRule()); } 
	 EOF 
;

// Rule AppendExpression
ruleAppendExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAppendExpressionAccess().getGroup()); }
		(rule__AppendExpression__Group__0)
		{ after(grammarAccess.getAppendExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLiteralExpression
entryRuleLiteralExpression
:
{ before(grammarAccess.getLiteralExpressionRule()); }
	 ruleLiteralExpression
{ after(grammarAccess.getLiteralExpressionRule()); } 
	 EOF 
;

// Rule LiteralExpression
ruleLiteralExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLiteralExpressionAccess().getAlternatives()); }
		(rule__LiteralExpression__Alternatives)
		{ after(grammarAccess.getLiteralExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleBooleanLiteral
entryRuleBooleanLiteral
:
{ before(grammarAccess.getBooleanLiteralRule()); }
	 ruleBooleanLiteral
{ after(grammarAccess.getBooleanLiteralRule()); } 
	 EOF 
;

// Rule BooleanLiteral
ruleBooleanLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getBooleanLiteralAccess().getAlternatives()); }
		(rule__BooleanLiteral__Alternatives)
		{ after(grammarAccess.getBooleanLiteralAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleNaturalLiteral
entryRuleNaturalLiteral
:
{ before(grammarAccess.getNaturalLiteralRule()); }
	 ruleNaturalLiteral
{ after(grammarAccess.getNaturalLiteralRule()); } 
	 EOF 
;

// Rule NaturalLiteral
ruleNaturalLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNaturalLiteralAccess().getValueAssignment()); }
		(rule__NaturalLiteral__ValueAssignment)
		{ after(grammarAccess.getNaturalLiteralAccess().getValueAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLowerBound
entryRuleLowerBound
:
{ before(grammarAccess.getLowerBoundRule()); }
	 ruleLowerBound
{ after(grammarAccess.getLowerBoundRule()); } 
	 EOF 
;

// Rule LowerBound
ruleLowerBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLowerBoundAccess().getAlternatives()); }
		(rule__LowerBound__Alternatives)
		{ after(grammarAccess.getLowerBoundAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUpperBound
entryRuleUpperBound
:
{ before(grammarAccess.getUpperBoundRule()); }
	 ruleUpperBound
{ after(grammarAccess.getUpperBoundRule()); } 
	 EOF 
;

// Rule UpperBound
ruleUpperBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUpperBoundAccess().getAlternatives()); }
		(rule__UpperBound__Alternatives)
		{ after(grammarAccess.getUpperBoundAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleNaturalLowerBound
entryRuleNaturalLowerBound
:
{ before(grammarAccess.getNaturalLowerBoundRule()); }
	 ruleNaturalLowerBound
{ after(grammarAccess.getNaturalLowerBoundRule()); } 
	 EOF 
;

// Rule NaturalLowerBound
ruleNaturalLowerBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNaturalLowerBoundAccess().getGroup()); }
		(rule__NaturalLowerBound__Group__0)
		{ after(grammarAccess.getNaturalLowerBoundAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleNaturalUpperBound
entryRuleNaturalUpperBound
:
{ before(grammarAccess.getNaturalUpperBoundRule()); }
	 ruleNaturalUpperBound
{ after(grammarAccess.getNaturalUpperBoundRule()); } 
	 EOF 
;

// Rule NaturalUpperBound
ruleNaturalUpperBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNaturalUpperBoundAccess().getGroup()); }
		(rule__NaturalUpperBound__Group__0)
		{ after(grammarAccess.getNaturalUpperBoundAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDecimalLowerBound
entryRuleDecimalLowerBound
:
{ before(grammarAccess.getDecimalLowerBoundRule()); }
	 ruleDecimalLowerBound
{ after(grammarAccess.getDecimalLowerBoundRule()); } 
	 EOF 
;

// Rule DecimalLowerBound
ruleDecimalLowerBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDecimalLowerBoundAccess().getGroup()); }
		(rule__DecimalLowerBound__Group__0)
		{ after(grammarAccess.getDecimalLowerBoundAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDecimalUpperBound
entryRuleDecimalUpperBound
:
{ before(grammarAccess.getDecimalUpperBoundRule()); }
	 ruleDecimalUpperBound
{ after(grammarAccess.getDecimalUpperBoundRule()); } 
	 EOF 
;

// Rule DecimalUpperBound
ruleDecimalUpperBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDecimalUpperBoundAccess().getGroup()); }
		(rule__DecimalUpperBound__Group__0)
		{ after(grammarAccess.getDecimalUpperBoundAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleVariableLowerBound
entryRuleVariableLowerBound
:
{ before(grammarAccess.getVariableLowerBoundRule()); }
	 ruleVariableLowerBound
{ after(grammarAccess.getVariableLowerBoundRule()); } 
	 EOF 
;

// Rule VariableLowerBound
ruleVariableLowerBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getVariableLowerBoundAccess().getGroup()); }
		(rule__VariableLowerBound__Group__0)
		{ after(grammarAccess.getVariableLowerBoundAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleVariableUpperBound
entryRuleVariableUpperBound
:
{ before(grammarAccess.getVariableUpperBoundRule()); }
	 ruleVariableUpperBound
{ after(grammarAccess.getVariableUpperBoundRule()); } 
	 EOF 
;

// Rule VariableUpperBound
ruleVariableUpperBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getVariableUpperBoundAccess().getGroup()); }
		(rule__VariableUpperBound__Group__0)
		{ after(grammarAccess.getVariableUpperBoundAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleInfiniteUpperBound
entryRuleInfiniteUpperBound
:
{ before(grammarAccess.getInfiniteUpperBoundRule()); }
	 ruleInfiniteUpperBound
{ after(grammarAccess.getInfiniteUpperBoundRule()); } 
	 EOF 
;

// Rule InfiniteUpperBound
ruleInfiniteUpperBound 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getInfiniteUpperBoundAccess().getGroup()); }
		(rule__InfiniteUpperBound__Group__0)
		{ after(grammarAccess.getInfiniteUpperBoundAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleRequirement
entryRuleRequirement
:
{ before(grammarAccess.getRequirementRule()); }
	 ruleRequirement
{ after(grammarAccess.getRequirementRule()); } 
	 EOF 
;

// Rule Requirement
ruleRequirement 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRequirementAccess().getGroup()); }
		(rule__Requirement__Group__0)
		{ after(grammarAccess.getRequirementAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePropertyDeclaration
entryRulePropertyDeclaration
:
{ before(grammarAccess.getPropertyDeclarationRule()); }
	 rulePropertyDeclaration
{ after(grammarAccess.getPropertyDeclarationRule()); } 
	 EOF 
;

// Rule PropertyDeclaration
rulePropertyDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPropertyDeclarationAccess().getGroup()); }
		(rule__PropertyDeclaration__Group__0)
		{ after(grammarAccess.getPropertyDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleProperty
entryRuleProperty
:
{ before(grammarAccess.getPropertyRule()); }
	 ruleProperty
{ after(grammarAccess.getPropertyRule()); } 
	 EOF 
;

// Rule Property
ruleProperty 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPropertyAccess().getQuantifiedPropertyParserRuleCall()); }
		ruleQuantifiedProperty
		{ after(grammarAccess.getPropertyAccess().getQuantifiedPropertyParserRuleCall()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleQuantifiedProperty
entryRuleQuantifiedProperty
:
{ before(grammarAccess.getQuantifiedPropertyRule()); }
	 ruleQuantifiedProperty
{ after(grammarAccess.getQuantifiedPropertyRule()); } 
	 EOF 
;

// Rule QuantifiedProperty
ruleQuantifiedProperty 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getQuantifiedPropertyAccess().getAlternatives()); }
		(rule__QuantifiedProperty__Alternatives)
		{ after(grammarAccess.getQuantifiedPropertyAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePropertyDisjunction
entryRulePropertyDisjunction
:
{ before(grammarAccess.getPropertyDisjunctionRule()); }
	 rulePropertyDisjunction
{ after(grammarAccess.getPropertyDisjunctionRule()); } 
	 EOF 
;

// Rule PropertyDisjunction
rulePropertyDisjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPropertyDisjunctionAccess().getGroup()); }
		(rule__PropertyDisjunction__Group__0)
		{ after(grammarAccess.getPropertyDisjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePropertyImplication
entryRulePropertyImplication
:
{ before(grammarAccess.getPropertyImplicationRule()); }
	 rulePropertyImplication
{ after(grammarAccess.getPropertyImplicationRule()); } 
	 EOF 
;

// Rule PropertyImplication
rulePropertyImplication 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPropertyImplicationAccess().getGroup()); }
		(rule__PropertyImplication__Group__0)
		{ after(grammarAccess.getPropertyImplicationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePropertyConjunction
entryRulePropertyConjunction
:
{ before(grammarAccess.getPropertyConjunctionRule()); }
	 rulePropertyConjunction
{ after(grammarAccess.getPropertyConjunctionRule()); } 
	 EOF 
;

// Rule PropertyConjunction
rulePropertyConjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPropertyConjunctionAccess().getGroup()); }
		(rule__PropertyConjunction__Group__0)
		{ after(grammarAccess.getPropertyConjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePropertyNegation
entryRulePropertyNegation
:
{ before(grammarAccess.getPropertyNegationRule()); }
	 rulePropertyNegation
{ after(grammarAccess.getPropertyNegationRule()); } 
	 EOF 
;

// Rule PropertyNegation
rulePropertyNegation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPropertyNegationAccess().getAlternatives()); }
		(rule__PropertyNegation__Alternatives)
		{ after(grammarAccess.getPropertyNegationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAtomicProperty
entryRuleAtomicProperty
:
{ before(grammarAccess.getAtomicPropertyRule()); }
	 ruleAtomicProperty
{ after(grammarAccess.getAtomicPropertyRule()); } 
	 EOF 
;

// Rule AtomicProperty
ruleAtomicProperty 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAtomicPropertyAccess().getAlternatives()); }
		(rule__AtomicProperty__Alternatives)
		{ after(grammarAccess.getAtomicPropertyAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePatternProperty
entryRulePatternProperty
:
{ before(grammarAccess.getPatternPropertyRule()); }
	 rulePatternProperty
{ after(grammarAccess.getPatternPropertyRule()); } 
	 EOF 
;

// Rule PatternProperty
rulePatternProperty 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPatternPropertyAccess().getAlternatives()); }
		(rule__PatternProperty__Alternatives)
		{ after(grammarAccess.getPatternPropertyAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLTLPattern
entryRuleLTLPattern
:
{ before(grammarAccess.getLTLPatternRule()); }
	 ruleLTLPattern
{ after(grammarAccess.getLTLPatternRule()); } 
	 EOF 
;

// Rule LTLPattern
ruleLTLPattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLTLPatternAccess().getGroup()); }
		(rule__LTLPattern__Group__0)
		{ after(grammarAccess.getLTLPatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDeadlockFreePattern
entryRuleDeadlockFreePattern
:
{ before(grammarAccess.getDeadlockFreePatternRule()); }
	 ruleDeadlockFreePattern
{ after(grammarAccess.getDeadlockFreePatternRule()); } 
	 EOF 
;

// Rule DeadlockFreePattern
ruleDeadlockFreePattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDeadlockFreePatternAccess().getGroup()); }
		(rule__DeadlockFreePattern__Group__0)
		{ after(grammarAccess.getDeadlockFreePatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleInfinitelyOftenPattern
entryRuleInfinitelyOftenPattern
:
{ before(grammarAccess.getInfinitelyOftenPatternRule()); }
	 ruleInfinitelyOftenPattern
{ after(grammarAccess.getInfinitelyOftenPatternRule()); } 
	 EOF 
;

// Rule InfinitelyOftenPattern
ruleInfinitelyOftenPattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getInfinitelyOftenPatternAccess().getGroup()); }
		(rule__InfinitelyOftenPattern__Group__0)
		{ after(grammarAccess.getInfinitelyOftenPatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleMortalPattern
entryRuleMortalPattern
:
{ before(grammarAccess.getMortalPatternRule()); }
	 ruleMortalPattern
{ after(grammarAccess.getMortalPatternRule()); } 
	 EOF 
;

// Rule MortalPattern
ruleMortalPattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getMortalPatternAccess().getGroup()); }
		(rule__MortalPattern__Group__0)
		{ after(grammarAccess.getMortalPatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePresencePattern
entryRulePresencePattern
:
{ before(grammarAccess.getPresencePatternRule()); }
	 rulePresencePattern
{ after(grammarAccess.getPresencePatternRule()); } 
	 EOF 
;

// Rule PresencePattern
rulePresencePattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPresencePatternAccess().getGroup()); }
		(rule__PresencePattern__Group__0)
		{ after(grammarAccess.getPresencePatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAbsencePattern
entryRuleAbsencePattern
:
{ before(grammarAccess.getAbsencePatternRule()); }
	 ruleAbsencePattern
{ after(grammarAccess.getAbsencePatternRule()); } 
	 EOF 
;

// Rule AbsencePattern
ruleAbsencePattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getGroup()); }
		(rule__AbsencePattern__Group__0)
		{ after(grammarAccess.getAbsencePatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAlwaysPattern
entryRuleAlwaysPattern
:
{ before(grammarAccess.getAlwaysPatternRule()); }
	 ruleAlwaysPattern
{ after(grammarAccess.getAlwaysPatternRule()); } 
	 EOF 
;

// Rule AlwaysPattern
ruleAlwaysPattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getGroup()); }
		(rule__AlwaysPattern__Group__0)
		{ after(grammarAccess.getAlwaysPatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleSequencePattern
entryRuleSequencePattern
:
{ before(grammarAccess.getSequencePatternRule()); }
	 ruleSequencePattern
{ after(grammarAccess.getSequencePatternRule()); } 
	 EOF 
;

// Rule SequencePattern
ruleSequencePattern 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup()); }
		(rule__SequencePattern__Group__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLTLProperty
entryRuleLTLProperty
:
{ before(grammarAccess.getLTLPropertyRule()); }
	 ruleLTLProperty
{ after(grammarAccess.getLTLPropertyRule()); } 
	 EOF 
;

// Rule LTLProperty
ruleLTLProperty 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLTLPropertyAccess().getLTLQuantifiedParserRuleCall()); }
		ruleLTLQuantified
		{ after(grammarAccess.getLTLPropertyAccess().getLTLQuantifiedParserRuleCall()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLTLQuantified
entryRuleLTLQuantified
:
{ before(grammarAccess.getLTLQuantifiedRule()); }
	 ruleLTLQuantified
{ after(grammarAccess.getLTLQuantifiedRule()); } 
	 EOF 
;

// Rule LTLQuantified
ruleLTLQuantified 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLTLQuantifiedAccess().getAlternatives()); }
		(rule__LTLQuantified__Alternatives)
		{ after(grammarAccess.getLTLQuantifiedAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLTLDisjunction
entryRuleLTLDisjunction
:
{ before(grammarAccess.getLTLDisjunctionRule()); }
	 ruleLTLDisjunction
{ after(grammarAccess.getLTLDisjunctionRule()); } 
	 EOF 
;

// Rule LTLDisjunction
ruleLTLDisjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLTLDisjunctionAccess().getGroup()); }
		(rule__LTLDisjunction__Group__0)
		{ after(grammarAccess.getLTLDisjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLTLImplication
entryRuleLTLImplication
:
{ before(grammarAccess.getLTLImplicationRule()); }
	 ruleLTLImplication
{ after(grammarAccess.getLTLImplicationRule()); } 
	 EOF 
;

// Rule LTLImplication
ruleLTLImplication 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLTLImplicationAccess().getGroup()); }
		(rule__LTLImplication__Group__0)
		{ after(grammarAccess.getLTLImplicationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLTLConjunction
entryRuleLTLConjunction
:
{ before(grammarAccess.getLTLConjunctionRule()); }
	 ruleLTLConjunction
{ after(grammarAccess.getLTLConjunctionRule()); } 
	 EOF 
;

// Rule LTLConjunction
ruleLTLConjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLTLConjunctionAccess().getGroup()); }
		(rule__LTLConjunction__Group__0)
		{ after(grammarAccess.getLTLConjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLTLBinary
entryRuleLTLBinary
:
{ before(grammarAccess.getLTLBinaryRule()); }
	 ruleLTLBinary
{ after(grammarAccess.getLTLBinaryRule()); } 
	 EOF 
;

// Rule LTLBinary
ruleLTLBinary 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLTLBinaryAccess().getGroup()); }
		(rule__LTLBinary__Group__0)
		{ after(grammarAccess.getLTLBinaryAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLTLUnary
entryRuleLTLUnary
:
{ before(grammarAccess.getLTLUnaryRule()); }
	 ruleLTLUnary
{ after(grammarAccess.getLTLUnaryRule()); } 
	 EOF 
;

// Rule LTLUnary
ruleLTLUnary 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLTLUnaryAccess().getAlternatives()); }
		(rule__LTLUnary__Alternatives)
		{ after(grammarAccess.getLTLUnaryAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAtomicLTL
entryRuleAtomicLTL
:
{ before(grammarAccess.getAtomicLTLRule()); }
	 ruleAtomicLTL
{ after(grammarAccess.getAtomicLTLRule()); } 
	 EOF 
;

// Rule AtomicLTL
ruleAtomicLTL 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAtomicLTLAccess().getAlternatives()); }
		(rule__AtomicLTL__Alternatives)
		{ after(grammarAccess.getAtomicLTLAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleStateEvent
entryRuleStateEvent
:
{ before(grammarAccess.getStateEventRule()); }
	 ruleStateEvent
{ after(grammarAccess.getStateEventRule()); } 
	 EOF 
;

// Rule StateEvent
ruleStateEvent 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getStateEventAccess().getAlternatives()); }
		(rule__StateEvent__Alternatives)
		{ after(grammarAccess.getStateEventAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleEnterStateEvent
entryRuleEnterStateEvent
:
{ before(grammarAccess.getEnterStateEventRule()); }
	 ruleEnterStateEvent
{ after(grammarAccess.getEnterStateEventRule()); } 
	 EOF 
;

// Rule EnterStateEvent
ruleEnterStateEvent 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getEnterStateEventAccess().getGroup()); }
		(rule__EnterStateEvent__Group__0)
		{ after(grammarAccess.getEnterStateEventAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLeaveStateEvent
entryRuleLeaveStateEvent
:
{ before(grammarAccess.getLeaveStateEventRule()); }
	 ruleLeaveStateEvent
{ after(grammarAccess.getLeaveStateEventRule()); } 
	 EOF 
;

// Rule LeaveStateEvent
ruleLeaveStateEvent 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLeaveStateEventAccess().getGroup()); }
		(rule__LeaveStateEvent__Group__0)
		{ after(grammarAccess.getLeaveStateEventAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleObservable
entryRuleObservable
:
{ before(grammarAccess.getObservableRule()); }
	 ruleObservable
{ after(grammarAccess.getObservableRule()); } 
	 EOF 
;

// Rule Observable
ruleObservable 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getObservableAccess().getObservableDisjunctionParserRuleCall()); }
		ruleObservableDisjunction
		{ after(grammarAccess.getObservableAccess().getObservableDisjunctionParserRuleCall()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleObservableDisjunction
entryRuleObservableDisjunction
:
{ before(grammarAccess.getObservableDisjunctionRule()); }
	 ruleObservableDisjunction
{ after(grammarAccess.getObservableDisjunctionRule()); } 
	 EOF 
;

// Rule ObservableDisjunction
ruleObservableDisjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getObservableDisjunctionAccess().getGroup()); }
		(rule__ObservableDisjunction__Group__0)
		{ after(grammarAccess.getObservableDisjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleObservableImplication
entryRuleObservableImplication
:
{ before(grammarAccess.getObservableImplicationRule()); }
	 ruleObservableImplication
{ after(grammarAccess.getObservableImplicationRule()); } 
	 EOF 
;

// Rule ObservableImplication
ruleObservableImplication 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getObservableImplicationAccess().getGroup()); }
		(rule__ObservableImplication__Group__0)
		{ after(grammarAccess.getObservableImplicationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleObservableConjunction
entryRuleObservableConjunction
:
{ before(grammarAccess.getObservableConjunctionRule()); }
	 ruleObservableConjunction
{ after(grammarAccess.getObservableConjunctionRule()); } 
	 EOF 
;

// Rule ObservableConjunction
ruleObservableConjunction 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getObservableConjunctionAccess().getGroup()); }
		(rule__ObservableConjunction__Group__0)
		{ after(grammarAccess.getObservableConjunctionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleObservableNegation
entryRuleObservableNegation
:
{ before(grammarAccess.getObservableNegationRule()); }
	 ruleObservableNegation
{ after(grammarAccess.getObservableNegationRule()); } 
	 EOF 
;

// Rule ObservableNegation
ruleObservableNegation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getObservableNegationAccess().getAlternatives()); }
		(rule__ObservableNegation__Alternatives)
		{ after(grammarAccess.getObservableNegationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAtomicObservable
entryRuleAtomicObservable
:
{ before(grammarAccess.getAtomicObservableRule()); }
	 ruleAtomicObservable
{ after(grammarAccess.getAtomicObservableRule()); } 
	 EOF 
;

// Rule AtomicObservable
ruleAtomicObservable 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAtomicObservableAccess().getAlternatives()); }
		(rule__AtomicObservable__Alternatives)
		{ after(grammarAccess.getAtomicObservableAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleObservableEvent
entryRuleObservableEvent
:
{ before(grammarAccess.getObservableEventRule()); }
	 ruleObservableEvent
{ after(grammarAccess.getObservableEventRule()); } 
	 EOF 
;

// Rule ObservableEvent
ruleObservableEvent 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getObservableEventAccess().getAlternatives()); }
		(rule__ObservableEvent__Alternatives)
		{ after(grammarAccess.getObservableEventAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePathEvent
entryRulePathEvent
:
{ before(grammarAccess.getPathEventRule()); }
	 rulePathEvent
{ after(grammarAccess.getPathEventRule()); } 
	 EOF 
;

// Rule PathEvent
rulePathEvent 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPathEventAccess().getGroup()); }
		(rule__PathEvent__Group__0)
		{ after(grammarAccess.getPathEventAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePath
entryRulePath
:
{ before(grammarAccess.getPathRule()); }
	 rulePath
{ after(grammarAccess.getPathRule()); } 
	 EOF 
;

// Rule Path
rulePath 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		(
			{ before(grammarAccess.getPathAccess().getGroup()); }
			(rule__Path__Group__0)
			{ after(grammarAccess.getPathAccess().getGroup()); }
		)
		(
			{ before(grammarAccess.getPathAccess().getGroup()); }
			(rule__Path__Group__0)*
			{ after(grammarAccess.getPathAccess().getGroup()); }
		)
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePathItem
entryRulePathItem
:
{ before(grammarAccess.getPathItemRule()); }
	 rulePathItem
{ after(grammarAccess.getPathItemRule()); } 
	 EOF 
;

// Rule PathItem
rulePathItem 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPathItemAccess().getAlternatives()); }
		(rule__PathItem__Alternatives)
		{ after(grammarAccess.getPathItemAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleNaturalItem
entryRuleNaturalItem
:
{ before(grammarAccess.getNaturalItemRule()); }
	 ruleNaturalItem
{ after(grammarAccess.getNaturalItemRule()); } 
	 EOF 
;

// Rule NaturalItem
ruleNaturalItem 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNaturalItemAccess().getValueAssignment()); }
		(rule__NaturalItem__ValueAssignment)
		{ after(grammarAccess.getNaturalItemAccess().getValueAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleNamedItem
entryRuleNamedItem
:
{ before(grammarAccess.getNamedItemRule()); }
	 ruleNamedItem
{ after(grammarAccess.getNamedItemRule()); } 
	 EOF 
;

// Rule NamedItem
ruleNamedItem 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNamedItemAccess().getDeclarationAssignment()); }
		(rule__NamedItem__DeclarationAssignment)
		{ after(grammarAccess.getNamedItemAccess().getDeclarationAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleSubject
entryRuleSubject
:
{ before(grammarAccess.getSubjectRule()); }
	 ruleSubject
{ after(grammarAccess.getSubjectRule()); } 
	 EOF 
;

// Rule Subject
ruleSubject 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getSubjectAccess().getAlternatives()); }
		(rule__Subject__Alternatives)
		{ after(grammarAccess.getSubjectAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleStateSubject
entryRuleStateSubject
:
{ before(grammarAccess.getStateSubjectRule()); }
	 ruleStateSubject
{ after(grammarAccess.getStateSubjectRule()); } 
	 EOF 
;

// Rule StateSubject
ruleStateSubject 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getStateSubjectAccess().getGroup()); }
		(rule__StateSubject__Group__0)
		{ after(grammarAccess.getStateSubjectAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleValueSubject
entryRuleValueSubject
:
{ before(grammarAccess.getValueSubjectRule()); }
	 ruleValueSubject
{ after(grammarAccess.getValueSubjectRule()); } 
	 EOF 
;

// Rule ValueSubject
ruleValueSubject 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getValueSubjectAccess().getGroup()); }
		(rule__ValueSubject__Group__0)
		{ after(grammarAccess.getValueSubjectAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTagSubject
entryRuleTagSubject
:
{ before(grammarAccess.getTagSubjectRule()); }
	 ruleTagSubject
{ after(grammarAccess.getTagSubjectRule()); } 
	 EOF 
;

// Rule TagSubject
ruleTagSubject 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTagSubjectAccess().getGroup()); }
		(rule__TagSubject__Group__0)
		{ after(grammarAccess.getTagSubjectAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleEventSubject
entryRuleEventSubject
:
{ before(grammarAccess.getEventSubjectRule()); }
	 ruleEventSubject
{ after(grammarAccess.getEventSubjectRule()); } 
	 EOF 
;

// Rule EventSubject
ruleEventSubject 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getEventSubjectAccess().getGroup()); }
		(rule__EventSubject__Group__0)
		{ after(grammarAccess.getEventSubjectAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__Alternatives_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getModelAccess().getDeclarationsAssignment_2_0()); }
		(rule__Model__DeclarationsAssignment_2_0)
		{ after(grammarAccess.getModelAccess().getDeclarationsAssignment_2_0()); }
	)
	|
	(
		{ before(grammarAccess.getModelAccess().getRequirementsAssignment_2_1()); }
		(rule__Model__RequirementsAssignment_2_1)
		{ after(grammarAccess.getModelAccess().getRequirementsAssignment_2_1()); }
	)
	|
	(
		{ before(grammarAccess.getModelAccess().getRootAssignment_2_2()); }
		(rule__Model__RootAssignment_2_2)
		{ after(grammarAccess.getModelAccess().getRootAssignment_2_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Declaration__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDeclarationAccess().getTypeDeclarationParserRuleCall_0()); }
		ruleTypeDeclaration
		{ after(grammarAccess.getDeclarationAccess().getTypeDeclarationParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getDeclarationAccess().getChannelDeclarationParserRuleCall_1()); }
		ruleChannelDeclaration
		{ after(grammarAccess.getDeclarationAccess().getChannelDeclarationParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getDeclarationAccess().getConstantDeclarationParserRuleCall_2()); }
		ruleConstantDeclaration
		{ after(grammarAccess.getDeclarationAccess().getConstantDeclarationParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getDeclarationAccess().getParameterizedDeclarationParserRuleCall_3()); }
		ruleParameterizedDeclaration
		{ after(grammarAccess.getDeclarationAccess().getParameterizedDeclarationParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getDeclarationAccess().getPropertyDeclarationParserRuleCall_4()); }
		rulePropertyDeclaration
		{ after(grammarAccess.getDeclarationAccess().getPropertyDeclarationParserRuleCall_4()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterizedDeclaration__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParameterizedDeclarationAccess().getProcessDeclarationParserRuleCall_0()); }
		ruleProcessDeclaration
		{ after(grammarAccess.getParameterizedDeclarationAccess().getProcessDeclarationParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getParameterizedDeclarationAccess().getComponentDeclarationParserRuleCall_1()); }
		ruleComponentDeclaration
		{ after(grammarAccess.getParameterizedDeclarationAccess().getComponentDeclarationParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getParameterizedDeclarationAccess().getFunctionDeclarationParserRuleCall_2()); }
		ruleFunctionDeclaration
		{ after(grammarAccess.getParameterizedDeclarationAccess().getFunctionDeclarationParserRuleCall_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Alternatives_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelTypeAccess().getGroup_2_0()); }
		(rule__ChannelType__Group_2_0__0)
		{ after(grammarAccess.getChannelTypeAccess().getGroup_2_0()); }
	)
	|
	(
		{ before(grammarAccess.getChannelTypeAccess().getNoneKeyword_2_1()); }
		'none'
		{ after(grammarAccess.getChannelTypeAccess().getNoneKeyword_2_1()); }
	)
	|
	(
		{ before(grammarAccess.getChannelTypeAccess().getSyncKeyword_2_2()); }
		'sync'
		{ after(grammarAccess.getChannelTypeAccess().getSyncKeyword_2_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Alternatives_2_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelTypeAccess().getGroup_2_0_0_0()); }
		(rule__ChannelType__Group_2_0_0_0__0)
		{ after(grammarAccess.getChannelTypeAccess().getGroup_2_0_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getChannelTypeAccess().getOutAssignment_2_0_0_1()); }
		(rule__ChannelType__OutAssignment_2_0_0_1)
		{ after(grammarAccess.getChannelTypeAccess().getOutAssignment_2_0_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Alternatives_2_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelTypeAccess().getTypeAssignment_2_0_1_0()); }
		(rule__ChannelType__TypeAssignment_2_0_1_0)
		{ after(grammarAccess.getChannelTypeAccess().getTypeAssignment_2_0_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getChannelTypeAccess().getNoneKeyword_2_0_1_1()); }
		'none'
		{ after(grammarAccess.getChannelTypeAccess().getNoneKeyword_2_0_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Type__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypeAccess().getBasicTypeParserRuleCall_0()); }
		ruleBasicType
		{ after(grammarAccess.getTypeAccess().getBasicTypeParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getTypeAccess().getRangeTypeParserRuleCall_1()); }
		ruleRangeType
		{ after(grammarAccess.getTypeAccess().getRangeTypeParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getTypeAccess().getUnionTypeParserRuleCall_2()); }
		ruleUnionType
		{ after(grammarAccess.getTypeAccess().getUnionTypeParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getTypeAccess().getRecordTypeParserRuleCall_3()); }
		ruleRecordType
		{ after(grammarAccess.getTypeAccess().getRecordTypeParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getTypeAccess().getQueueTypeParserRuleCall_4()); }
		ruleQueueType
		{ after(grammarAccess.getTypeAccess().getQueueTypeParserRuleCall_4()); }
	)
	|
	(
		{ before(grammarAccess.getTypeAccess().getArrayTypeParserRuleCall_5()); }
		ruleArrayType
		{ after(grammarAccess.getTypeAccess().getArrayTypeParserRuleCall_5()); }
	)
	|
	(
		{ before(grammarAccess.getTypeAccess().getReferencedTypeParserRuleCall_6()); }
		ruleReferencedType
		{ after(grammarAccess.getTypeAccess().getReferencedTypeParserRuleCall_6()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBasicTypeAccess().getGroup_0()); }
		(rule__BasicType__Group_0__0)
		{ after(grammarAccess.getBasicTypeAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getBasicTypeAccess().getGroup_1()); }
		(rule__BasicType__Group_1__0)
		{ after(grammarAccess.getBasicTypeAccess().getGroup_1()); }
	)
	|
	(
		{ before(grammarAccess.getBasicTypeAccess().getGroup_2()); }
		(rule__BasicType__Group_2__0)
		{ after(grammarAccess.getBasicTypeAccess().getGroup_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Statement__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStatementAccess().getNullStatementParserRuleCall_0()); }
		ruleNullStatement
		{ after(grammarAccess.getStatementAccess().getNullStatementParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getTaggedStatementParserRuleCall_1()); }
		ruleTaggedStatement
		{ after(grammarAccess.getStatementAccess().getTaggedStatementParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getPatternStatementParserRuleCall_2()); }
		rulePatternStatement
		{ after(grammarAccess.getStatementAccess().getPatternStatementParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getConditionalStatementParserRuleCall_3()); }
		ruleConditionalStatement
		{ after(grammarAccess.getStatementAccess().getConditionalStatementParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getSelectStatementParserRuleCall_4()); }
		ruleSelectStatement
		{ after(grammarAccess.getStatementAccess().getSelectStatementParserRuleCall_4()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_5()); }
		ruleWhileStatement
		{ after(grammarAccess.getStatementAccess().getWhileStatementParserRuleCall_5()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getForeachStatementParserRuleCall_6()); }
		ruleForeachStatement
		{ after(grammarAccess.getStatementAccess().getForeachStatementParserRuleCall_6()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getToStatementParserRuleCall_7()); }
		ruleToStatement
		{ after(grammarAccess.getStatementAccess().getToStatementParserRuleCall_7()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getCaseStatementParserRuleCall_8()); }
		ruleCaseStatement
		{ after(grammarAccess.getStatementAccess().getCaseStatementParserRuleCall_8()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getLoopStatementParserRuleCall_9()); }
		ruleLoopStatement
		{ after(grammarAccess.getStatementAccess().getLoopStatementParserRuleCall_9()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getOnStatementParserRuleCall_10()); }
		ruleOnStatement
		{ after(grammarAccess.getStatementAccess().getOnStatementParserRuleCall_10()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getWaitStatementParserRuleCall_11()); }
		ruleWaitStatement
		{ after(grammarAccess.getStatementAccess().getWaitStatementParserRuleCall_11()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_12()); }
		ruleReturnStatement
		{ after(grammarAccess.getStatementAccess().getReturnStatementParserRuleCall_12()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_13()); }
		ruleBlockStatement
		{ after(grammarAccess.getStatementAccess().getBlockStatementParserRuleCall_13()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getGroup_1_0()); }
		(rule__PatternStatement__Group_1_0__0)
		{ after(grammarAccess.getPatternStatementAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getPatternStatementAccess().getGroup_1_1()); }
		(rule__PatternStatement__Group_1_1__0)
		{ after(grammarAccess.getPatternStatementAccess().getGroup_1_1()); }
	)
	|
	(
		{ before(grammarAccess.getPatternStatementAccess().getGroup_1_2()); }
		(rule__PatternStatement__Group_1_2__0)
		{ after(grammarAccess.getPatternStatementAccess().getGroup_1_2()); }
	)
	|
	(
		{ before(grammarAccess.getPatternStatementAccess().getGroup_1_3()); }
		(rule__PatternStatement__Group_1_3__0)
		{ after(grammarAccess.getPatternStatementAccess().getGroup_1_3()); }
	)
	|
	(
		{ before(grammarAccess.getPatternStatementAccess().getGroup_1_4()); }
		(rule__PatternStatement__Group_1_4__0)
		{ after(grammarAccess.getPatternStatementAccess().getGroup_1_4()); }
	)
	|
	(
		{ before(grammarAccess.getPatternStatementAccess().getGroup_1_5()); }
		(rule__PatternStatement__Group_1_5__0)
		{ after(grammarAccess.getPatternStatementAccess().getGroup_1_5()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Pattern__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternAccess().getAnyPatternParserRuleCall_0()); }
		ruleAnyPattern
		{ after(grammarAccess.getPatternAccess().getAnyPatternParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getPatternAccess().getIntegerPatternParserRuleCall_1()); }
		ruleIntegerPattern
		{ after(grammarAccess.getPatternAccess().getIntegerPatternParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getPatternAccess().getConstantPatternParserRuleCall_2()); }
		ruleConstantPattern
		{ after(grammarAccess.getPatternAccess().getConstantPatternParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getPatternAccess().getGroup_3()); }
		(rule__Pattern__Group_3__0)
		{ after(grammarAccess.getPatternAccess().getGroup_3()); }
	)
	|
	(
		{ before(grammarAccess.getPatternAccess().getIdentifierPatternParserRuleCall_4()); }
		ruleIdentifierPattern
		{ after(grammarAccess.getPatternAccess().getIdentifierPatternParserRuleCall_4()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerPattern__Alternatives_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIntegerPatternAccess().getPlusSignKeyword_0_0()); }
		'+'
		{ after(grammarAccess.getIntegerPatternAccess().getPlusSignKeyword_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getIntegerPatternAccess().getNegativeAssignment_0_1()); }
		(rule__IntegerPattern__NegativeAssignment_0_1)
		{ after(grammarAccess.getIntegerPatternAccess().getNegativeAssignment_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getGroup_0()); }
		(rule__IdentifierPattern__Group_0__0)
		{ after(grammarAccess.getIdentifierPatternAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getGroup_1()); }
		(rule__IdentifierPattern__Group_1__0)
		{ after(grammarAccess.getIdentifierPatternAccess().getGroup_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Alternatives_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getGroup_1_1_0()); }
		(rule__IdentifierPattern__Group_1_1_0__0)
		{ after(grammarAccess.getIdentifierPatternAccess().getGroup_1_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getGroup_1_1_1()); }
		(rule__IdentifierPattern__Group_1_1_1__0)
		{ after(grammarAccess.getIdentifierPatternAccess().getGroup_1_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Block__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBlockAccess().getCompositeBlockParserRuleCall_0()); }
		ruleCompositeBlock
		{ after(grammarAccess.getBlockAccess().getCompositeBlockParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getBlockAccess().getInstanceDeclarationParserRuleCall_1()); }
		ruleInstanceDeclaration
		{ after(grammarAccess.getBlockAccess().getInstanceDeclarationParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__Alternatives_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCompositeBlockAccess().getGroup_0_0()); }
		(rule__CompositeBlock__Group_0_0__0)
		{ after(grammarAccess.getCompositeBlockAccess().getGroup_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getCompositeBlockAccess().getHyphenMinusGreaterThanSignKeyword_0_1()); }
		'->'
		{ after(grammarAccess.getCompositeBlockAccess().getHyphenMinusGreaterThanSignKeyword_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__Alternatives_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getInstanceDeclarationAccess().getGroup_0_0()); }
		(rule__InstanceDeclaration__Group_0_0__0)
		{ after(grammarAccess.getInstanceDeclarationAccess().getGroup_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getInstanceDeclarationAccess().getHyphenMinusGreaterThanSignKeyword_0_1()); }
		'->'
		{ after(grammarAccess.getInstanceDeclarationAccess().getHyphenMinusGreaterThanSignKeyword_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPortSetAccess().getAllPortsAssignment_0()); }
		(rule__PortSet__AllPortsAssignment_0)
		{ after(grammarAccess.getPortSetAccess().getAllPortsAssignment_0()); }
	)
	|
	(
		{ before(grammarAccess.getPortSetAccess().getGroup_1()); }
		(rule__PortSet__Group_1__0)
		{ after(grammarAccess.getPortSetAccess().getGroup_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getGroup_0()); }
		(rule__QuantifiedExpression__Group_0__0)
		{ after(grammarAccess.getQuantifiedExpressionAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getConditionalParserRuleCall_1()); }
		ruleConditional
		{ after(grammarAccess.getQuantifiedExpressionAccess().getConditionalParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Alternatives_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getGroup_0_0_0()); }
		(rule__QuantifiedExpression__Group_0_0_0__0)
		{ after(grammarAccess.getQuantifiedExpressionAccess().getGroup_0_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getGroup_0_0_1()); }
		(rule__QuantifiedExpression__Group_0_0_1__0)
		{ after(grammarAccess.getQuantifiedExpressionAccess().getGroup_0_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Alternatives_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComparisonAccess().getGroup_1_0_0()); }
		(rule__Comparison__Group_1_0_0__0)
		{ after(grammarAccess.getComparisonAccess().getGroup_1_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonAccess().getGroup_1_0_1()); }
		(rule__Comparison__Group_1_0_1__0)
		{ after(grammarAccess.getComparisonAccess().getGroup_1_0_1()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonAccess().getGroup_1_0_2()); }
		(rule__Comparison__Group_1_0_2__0)
		{ after(grammarAccess.getComparisonAccess().getGroup_1_0_2()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonAccess().getGroup_1_0_3()); }
		(rule__Comparison__Group_1_0_3__0)
		{ after(grammarAccess.getComparisonAccess().getGroup_1_0_3()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonAccess().getGroup_1_0_4()); }
		(rule__Comparison__Group_1_0_4__0)
		{ after(grammarAccess.getComparisonAccess().getGroup_1_0_4()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonAccess().getGroup_1_0_5()); }
		(rule__Comparison__Group_1_0_5__0)
		{ after(grammarAccess.getComparisonAccess().getGroup_1_0_5()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0()); }
		(rule__UnaryExpression__Group_0__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getProjectionParserRuleCall_1()); }
		ruleProjection
		{ after(grammarAccess.getUnaryExpressionAccess().getProjectionParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Alternatives_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_0()); }
		(rule__UnaryExpression__Group_0_0_0__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_1()); }
		(rule__UnaryExpression__Group_0_0_1__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_1()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_2()); }
		(rule__UnaryExpression__Group_0_0_2__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_2()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_3()); }
		(rule__UnaryExpression__Group_0_0_3__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_3()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_4()); }
		(rule__UnaryExpression__Group_0_0_4__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_4()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_5()); }
		(rule__UnaryExpression__Group_0_0_5__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_5()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_6()); }
		(rule__UnaryExpression__Group_0_0_6__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_6()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_7()); }
		(rule__UnaryExpression__Group_0_0_7__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_7()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_8()); }
		(rule__UnaryExpression__Group_0_0_8__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_0_0_8()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getIdentifierExpressionParserRuleCall_0()); }
		ruleIdentifierExpression
		{ after(grammarAccess.getAtomicExpressionAccess().getIdentifierExpressionParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getReferenceExpressionParserRuleCall_1()); }
		ruleReferenceExpression
		{ after(grammarAccess.getAtomicExpressionAccess().getReferenceExpressionParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getLiteralExpressionParserRuleCall_2()); }
		ruleLiteralExpression
		{ after(grammarAccess.getAtomicExpressionAccess().getLiteralExpressionParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getRecordExpressionParserRuleCall_3()); }
		ruleRecordExpression
		{ after(grammarAccess.getAtomicExpressionAccess().getRecordExpressionParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getArrayExpressionParserRuleCall_4()); }
		ruleArrayExpression
		{ after(grammarAccess.getAtomicExpressionAccess().getArrayExpressionParserRuleCall_4()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getQueueExpressionParserRuleCall_5()); }
		ruleQueueExpression
		{ after(grammarAccess.getAtomicExpressionAccess().getQueueExpressionParserRuleCall_5()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getEnqueueExpressionParserRuleCall_6()); }
		ruleEnqueueExpression
		{ after(grammarAccess.getAtomicExpressionAccess().getEnqueueExpressionParserRuleCall_6()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getAppendExpressionParserRuleCall_7()); }
		ruleAppendExpression
		{ after(grammarAccess.getAtomicExpressionAccess().getAppendExpressionParserRuleCall_7()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getGroup_8()); }
		(rule__AtomicExpression__Group_8__0)
		{ after(grammarAccess.getAtomicExpressionAccess().getGroup_8()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getGroup_0()); }
		(rule__IdentifierExpression__Group_0__0)
		{ after(grammarAccess.getIdentifierExpressionAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getGroup_1()); }
		(rule__IdentifierExpression__Group_1__0)
		{ after(grammarAccess.getIdentifierExpressionAccess().getGroup_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Alternatives_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getGroup_1_1_0()); }
		(rule__IdentifierExpression__Group_1_1_0__0)
		{ after(grammarAccess.getIdentifierExpressionAccess().getGroup_1_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getGroup_1_1_1()); }
		(rule__IdentifierExpression__Group_1_1_1__0)
		{ after(grammarAccess.getIdentifierExpressionAccess().getGroup_1_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LiteralExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLiteralExpressionAccess().getBooleanLiteralParserRuleCall_0()); }
		ruleBooleanLiteral
		{ after(grammarAccess.getLiteralExpressionAccess().getBooleanLiteralParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralExpressionAccess().getNaturalLiteralParserRuleCall_1()); }
		ruleNaturalLiteral
		{ after(grammarAccess.getLiteralExpressionAccess().getNaturalLiteralParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBooleanLiteralAccess().getGroup_0()); }
		(rule__BooleanLiteral__Group_0__0)
		{ after(grammarAccess.getBooleanLiteralAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getBooleanLiteralAccess().getGroup_1()); }
		(rule__BooleanLiteral__Group_1__0)
		{ after(grammarAccess.getBooleanLiteralAccess().getGroup_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBound__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundAccess().getNaturalLowerBoundParserRuleCall_0()); }
		ruleNaturalLowerBound
		{ after(grammarAccess.getLowerBoundAccess().getNaturalLowerBoundParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getLowerBoundAccess().getDecimalLowerBoundParserRuleCall_1()); }
		ruleDecimalLowerBound
		{ after(grammarAccess.getLowerBoundAccess().getDecimalLowerBoundParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getLowerBoundAccess().getVariableLowerBoundParserRuleCall_2()); }
		ruleVariableLowerBound
		{ after(grammarAccess.getLowerBoundAccess().getVariableLowerBoundParserRuleCall_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UpperBound__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUpperBoundAccess().getNaturalUpperBoundParserRuleCall_0()); }
		ruleNaturalUpperBound
		{ after(grammarAccess.getUpperBoundAccess().getNaturalUpperBoundParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getUpperBoundAccess().getDecimalUpperBoundParserRuleCall_1()); }
		ruleDecimalUpperBound
		{ after(grammarAccess.getUpperBoundAccess().getDecimalUpperBoundParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getUpperBoundAccess().getVariableUpperBoundParserRuleCall_2()); }
		ruleVariableUpperBound
		{ after(grammarAccess.getUpperBoundAccess().getVariableUpperBoundParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getUpperBoundAccess().getInfiniteUpperBoundParserRuleCall_3()); }
		ruleInfiniteUpperBound
		{ after(grammarAccess.getUpperBoundAccess().getInfiniteUpperBoundParserRuleCall_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalLowerBound__Alternatives_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalLowerBoundAccess().getLeftAssignment_0_0()); }
		(rule__NaturalLowerBound__LeftAssignment_0_0)
		{ after(grammarAccess.getNaturalLowerBoundAccess().getLeftAssignment_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getNaturalLowerBoundAccess().getRightAssignment_0_1()); }
		(rule__NaturalLowerBound__RightAssignment_0_1)
		{ after(grammarAccess.getNaturalLowerBoundAccess().getRightAssignment_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalUpperBound__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalUpperBoundAccess().getLeftAssignment_1_0()); }
		(rule__NaturalUpperBound__LeftAssignment_1_0)
		{ after(grammarAccess.getNaturalUpperBoundAccess().getLeftAssignment_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getNaturalUpperBoundAccess().getRightAssignment_1_1()); }
		(rule__NaturalUpperBound__RightAssignment_1_1)
		{ after(grammarAccess.getNaturalUpperBoundAccess().getRightAssignment_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalLowerBound__Alternatives_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDecimalLowerBoundAccess().getLeftAssignment_0_0()); }
		(rule__DecimalLowerBound__LeftAssignment_0_0)
		{ after(grammarAccess.getDecimalLowerBoundAccess().getLeftAssignment_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getDecimalLowerBoundAccess().getRightAssignment_0_1()); }
		(rule__DecimalLowerBound__RightAssignment_0_1)
		{ after(grammarAccess.getDecimalLowerBoundAccess().getRightAssignment_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalUpperBound__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDecimalUpperBoundAccess().getLeftAssignment_1_0()); }
		(rule__DecimalUpperBound__LeftAssignment_1_0)
		{ after(grammarAccess.getDecimalUpperBoundAccess().getLeftAssignment_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getDecimalUpperBoundAccess().getRightAssignment_1_1()); }
		(rule__DecimalUpperBound__RightAssignment_1_1)
		{ after(grammarAccess.getDecimalUpperBoundAccess().getRightAssignment_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableLowerBound__Alternatives_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableLowerBoundAccess().getLeftAssignment_0_0()); }
		(rule__VariableLowerBound__LeftAssignment_0_0)
		{ after(grammarAccess.getVariableLowerBoundAccess().getLeftAssignment_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getVariableLowerBoundAccess().getRightAssignment_0_1()); }
		(rule__VariableLowerBound__RightAssignment_0_1)
		{ after(grammarAccess.getVariableLowerBoundAccess().getRightAssignment_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableUpperBound__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableUpperBoundAccess().getLeftAssignment_1_0()); }
		(rule__VariableUpperBound__LeftAssignment_1_0)
		{ after(grammarAccess.getVariableUpperBoundAccess().getLeftAssignment_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getVariableUpperBoundAccess().getRightAssignment_1_1()); }
		(rule__VariableUpperBound__RightAssignment_1_1)
		{ after(grammarAccess.getVariableUpperBoundAccess().getRightAssignment_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedPropertyAccess().getGroup_0()); }
		(rule__QuantifiedProperty__Group_0__0)
		{ after(grammarAccess.getQuantifiedPropertyAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getQuantifiedPropertyAccess().getPropertyDisjunctionParserRuleCall_1()); }
		rulePropertyDisjunction
		{ after(grammarAccess.getQuantifiedPropertyAccess().getPropertyDisjunctionParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Alternatives_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedPropertyAccess().getGroup_0_0_0()); }
		(rule__QuantifiedProperty__Group_0_0_0__0)
		{ after(grammarAccess.getQuantifiedPropertyAccess().getGroup_0_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getQuantifiedPropertyAccess().getGroup_0_0_1()); }
		(rule__QuantifiedProperty__Group_0_0_1__0)
		{ after(grammarAccess.getQuantifiedPropertyAccess().getGroup_0_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyNegation__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPropertyNegationAccess().getGroup_0()); }
		(rule__PropertyNegation__Group_0__0)
		{ after(grammarAccess.getPropertyNegationAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getPropertyNegationAccess().getAtomicPropertyParserRuleCall_1()); }
		ruleAtomicProperty
		{ after(grammarAccess.getPropertyNegationAccess().getAtomicPropertyParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicProperty__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAtomicPropertyAccess().getPatternPropertyParserRuleCall_0()); }
		rulePatternProperty
		{ after(grammarAccess.getAtomicPropertyAccess().getPatternPropertyParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicPropertyAccess().getGroup_1()); }
		(rule__AtomicProperty__Group_1__0)
		{ after(grammarAccess.getAtomicPropertyAccess().getGroup_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternProperty__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternPropertyAccess().getLTLPatternParserRuleCall_0()); }
		ruleLTLPattern
		{ after(grammarAccess.getPatternPropertyAccess().getLTLPatternParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getPatternPropertyAccess().getDeadlockFreePatternParserRuleCall_1()); }
		ruleDeadlockFreePattern
		{ after(grammarAccess.getPatternPropertyAccess().getDeadlockFreePatternParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getPatternPropertyAccess().getInfinitelyOftenPatternParserRuleCall_2()); }
		ruleInfinitelyOftenPattern
		{ after(grammarAccess.getPatternPropertyAccess().getInfinitelyOftenPatternParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getPatternPropertyAccess().getMortalPatternParserRuleCall_3()); }
		ruleMortalPattern
		{ after(grammarAccess.getPatternPropertyAccess().getMortalPatternParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getPatternPropertyAccess().getPresencePatternParserRuleCall_4()); }
		rulePresencePattern
		{ after(grammarAccess.getPatternPropertyAccess().getPresencePatternParserRuleCall_4()); }
	)
	|
	(
		{ before(grammarAccess.getPatternPropertyAccess().getAbsencePatternParserRuleCall_5()); }
		ruleAbsencePattern
		{ after(grammarAccess.getPatternPropertyAccess().getAbsencePatternParserRuleCall_5()); }
	)
	|
	(
		{ before(grammarAccess.getPatternPropertyAccess().getAlwaysPatternParserRuleCall_6()); }
		ruleAlwaysPattern
		{ after(grammarAccess.getPatternPropertyAccess().getAlwaysPatternParserRuleCall_6()); }
	)
	|
	(
		{ before(grammarAccess.getPatternPropertyAccess().getSequencePatternParserRuleCall_7()); }
		ruleSequencePattern
		{ after(grammarAccess.getPatternPropertyAccess().getSequencePatternParserRuleCall_7()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Alternatives_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getGroup_2_0()); }
		(rule__PresencePattern__Group_2_0__0)
		{ after(grammarAccess.getPresencePatternAccess().getGroup_2_0()); }
	)
	|
	(
		{ before(grammarAccess.getPresencePatternAccess().getGroup_2_1()); }
		(rule__PresencePattern__Group_2_1__0)
		{ after(grammarAccess.getPresencePatternAccess().getGroup_2_1()); }
	)
	|
	(
		{ before(grammarAccess.getPresencePatternAccess().getGroup_2_2()); }
		(rule__PresencePattern__Group_2_2__0)
		{ after(grammarAccess.getPresencePatternAccess().getGroup_2_2()); }
	)
	|
	(
		{ before(grammarAccess.getPresencePatternAccess().getGroup_2_3()); }
		(rule__PresencePattern__Group_2_3__0)
		{ after(grammarAccess.getPresencePatternAccess().getGroup_2_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Alternatives_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getGroup_2_1_1_0()); }
		(rule__PresencePattern__Group_2_1_1_0__0)
		{ after(grammarAccess.getPresencePatternAccess().getGroup_2_1_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getPresencePatternAccess().getGroup_2_1_1_1()); }
		(rule__PresencePattern__Group_2_1_1_1__0)
		{ after(grammarAccess.getPresencePatternAccess().getGroup_2_1_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Alternatives_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getGroup_2_0()); }
		(rule__AbsencePattern__Group_2_0__0)
		{ after(grammarAccess.getAbsencePatternAccess().getGroup_2_0()); }
	)
	|
	(
		{ before(grammarAccess.getAbsencePatternAccess().getGroup_2_1()); }
		(rule__AbsencePattern__Group_2_1__0)
		{ after(grammarAccess.getAbsencePatternAccess().getGroup_2_1()); }
	)
	|
	(
		{ before(grammarAccess.getAbsencePatternAccess().getGroup_2_2()); }
		(rule__AbsencePattern__Group_2_2__0)
		{ after(grammarAccess.getAbsencePatternAccess().getGroup_2_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Alternatives_2_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getGroup_2_0_1_0()); }
		(rule__AbsencePattern__Group_2_0_1_0__0)
		{ after(grammarAccess.getAbsencePatternAccess().getGroup_2_0_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getAbsencePatternAccess().getGroup_2_0_1_1()); }
		(rule__AbsencePattern__Group_2_0_1_1__0)
		{ after(grammarAccess.getAbsencePatternAccess().getGroup_2_0_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Alternatives_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getGroup_2_0()); }
		(rule__AlwaysPattern__Group_2_0__0)
		{ after(grammarAccess.getAlwaysPatternAccess().getGroup_2_0()); }
	)
	|
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getGroup_2_1()); }
		(rule__AlwaysPattern__Group_2_1__0)
		{ after(grammarAccess.getAlwaysPatternAccess().getGroup_2_1()); }
	)
	|
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getGroup_2_2()); }
		(rule__AlwaysPattern__Group_2_2__0)
		{ after(grammarAccess.getAlwaysPatternAccess().getGroup_2_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_0()); }
		(rule__SequencePattern__Group_1_0__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_1()); }
		(rule__SequencePattern__Group_1_1__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Alternatives_1_0_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_0()); }
		(rule__SequencePattern__Group_1_0_3_0__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_0()); }
	)
	|
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_1()); }
		(rule__SequencePattern__Group_1_0_3_1__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_1()); }
	)
	|
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_2()); }
		(rule__SequencePattern__Group_1_0_3_2__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_2()); }
	)
	|
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_3()); }
		(rule__SequencePattern__Group_1_0_3_3__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Alternatives_1_0_3_2_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_2_2_0()); }
		(rule__SequencePattern__Group_1_0_3_2_2_0__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_2_2_0()); }
	)
	|
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_2_2_1()); }
		(rule__SequencePattern__Group_1_0_3_2_2_1__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_2_2_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Alternatives_1_1_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_1_3_0()); }
		(rule__SequencePattern__Group_1_1_3_0__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_1_3_0()); }
	)
	|
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_1_3_1()); }
		(rule__SequencePattern__Group_1_1_3_1__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_1_3_1()); }
	)
	|
	(
		{ before(grammarAccess.getSequencePatternAccess().getGroup_1_1_3_2()); }
		(rule__SequencePattern__Group_1_1_3_2__0)
		{ after(grammarAccess.getSequencePatternAccess().getGroup_1_1_3_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLQuantifiedAccess().getGroup_0()); }
		(rule__LTLQuantified__Group_0__0)
		{ after(grammarAccess.getLTLQuantifiedAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getLTLQuantifiedAccess().getLTLDisjunctionParserRuleCall_1()); }
		ruleLTLDisjunction
		{ after(grammarAccess.getLTLQuantifiedAccess().getLTLDisjunctionParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Alternatives_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLQuantifiedAccess().getGroup_0_0_0()); }
		(rule__LTLQuantified__Group_0_0_0__0)
		{ after(grammarAccess.getLTLQuantifiedAccess().getGroup_0_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getLTLQuantifiedAccess().getGroup_0_0_1()); }
		(rule__LTLQuantified__Group_0_0_1__0)
		{ after(grammarAccess.getLTLQuantifiedAccess().getGroup_0_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLBinaryAccess().getGroup_1_0()); }
		(rule__LTLBinary__Group_1_0__0)
		{ after(grammarAccess.getLTLBinaryAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getLTLBinaryAccess().getGroup_1_1()); }
		(rule__LTLBinary__Group_1_1__0)
		{ after(grammarAccess.getLTLBinaryAccess().getGroup_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLUnaryAccess().getGroup_0()); }
		(rule__LTLUnary__Group_0__0)
		{ after(grammarAccess.getLTLUnaryAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getLTLUnaryAccess().getAtomicLTLParserRuleCall_1()); }
		ruleAtomicLTL
		{ after(grammarAccess.getLTLUnaryAccess().getAtomicLTLParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Alternatives_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLUnaryAccess().getGroup_0_0_0()); }
		(rule__LTLUnary__Group_0_0_0__0)
		{ after(grammarAccess.getLTLUnaryAccess().getGroup_0_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getLTLUnaryAccess().getGroup_0_0_1()); }
		(rule__LTLUnary__Group_0_0_1__0)
		{ after(grammarAccess.getLTLUnaryAccess().getGroup_0_0_1()); }
	)
	|
	(
		{ before(grammarAccess.getLTLUnaryAccess().getGroup_0_0_2()); }
		(rule__LTLUnary__Group_0_0_2__0)
		{ after(grammarAccess.getLTLUnaryAccess().getGroup_0_0_2()); }
	)
	|
	(
		{ before(grammarAccess.getLTLUnaryAccess().getGroup_0_0_3()); }
		(rule__LTLUnary__Group_0_0_3__0)
		{ after(grammarAccess.getLTLUnaryAccess().getGroup_0_0_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAtomicLTLAccess().getGroup_0()); }
		(rule__AtomicLTL__Group_0__0)
		{ after(grammarAccess.getAtomicLTLAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicLTLAccess().getObservableEventParserRuleCall_1()); }
		ruleObservableEvent
		{ after(grammarAccess.getAtomicLTLAccess().getObservableEventParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicLTLAccess().getGroup_2()); }
		(rule__AtomicLTL__Group_2__0)
		{ after(grammarAccess.getAtomicLTLAccess().getGroup_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__StateEvent__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStateEventAccess().getEnterStateEventParserRuleCall_0()); }
		ruleEnterStateEvent
		{ after(grammarAccess.getStateEventAccess().getEnterStateEventParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getStateEventAccess().getLeaveStateEventParserRuleCall_1()); }
		ruleLeaveStateEvent
		{ after(grammarAccess.getStateEventAccess().getLeaveStateEventParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableNegation__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObservableNegationAccess().getGroup_0()); }
		(rule__ObservableNegation__Group_0__0)
		{ after(grammarAccess.getObservableNegationAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getObservableNegationAccess().getAtomicObservableParserRuleCall_1()); }
		ruleAtomicObservable
		{ after(grammarAccess.getObservableNegationAccess().getAtomicObservableParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicObservable__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAtomicObservableAccess().getGroup_0()); }
		(rule__AtomicObservable__Group_0__0)
		{ after(grammarAccess.getAtomicObservableAccess().getGroup_0()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicObservableAccess().getObservableEventParserRuleCall_1()); }
		ruleObservableEvent
		{ after(grammarAccess.getAtomicObservableAccess().getObservableEventParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableEvent__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObservableEventAccess().getPathEventParserRuleCall_0()); }
		rulePathEvent
		{ after(grammarAccess.getObservableEventAccess().getPathEventParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getObservableEventAccess().getStateEventParserRuleCall_1()); }
		ruleStateEvent
		{ after(grammarAccess.getObservableEventAccess().getStateEventParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathItem__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathItemAccess().getNaturalItemParserRuleCall_0()); }
		ruleNaturalItem
		{ after(grammarAccess.getPathItemAccess().getNaturalItemParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getPathItemAccess().getNamedItemParserRuleCall_1()); }
		ruleNamedItem
		{ after(grammarAccess.getPathItemAccess().getNamedItemParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Subject__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSubjectAccess().getStateSubjectParserRuleCall_0()); }
		ruleStateSubject
		{ after(grammarAccess.getSubjectAccess().getStateSubjectParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getSubjectAccess().getValueSubjectParserRuleCall_1()); }
		ruleValueSubject
		{ after(grammarAccess.getSubjectAccess().getValueSubjectParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getSubjectAccess().getTagSubjectParserRuleCall_2()); }
		ruleTagSubject
		{ after(grammarAccess.getSubjectAccess().getTagSubjectParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getSubjectAccess().getEventSubjectParserRuleCall_3()); }
		ruleEventSubject
		{ after(grammarAccess.getSubjectAccess().getEventSubjectParserRuleCall_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Model__Group__0__Impl
	rule__Model__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getModelAccess().getModelAction_0()); }
	()
	{ after(grammarAccess.getModelAccess().getModelAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Model__Group__1__Impl
	rule__Model__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getModelAccess().getImportsAssignment_1()); }
	(rule__Model__ImportsAssignment_1)*
	{ after(grammarAccess.getModelAccess().getImportsAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Model__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getModelAccess().getAlternatives_2()); }
	(rule__Model__Alternatives_2)*
	{ after(grammarAccess.getModelAccess().getAlternatives_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Root__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group__0__Impl
	rule__Root__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getRootAction_0()); }
	()
	{ after(grammarAccess.getRootAccess().getRootAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group__1__Impl
	rule__Root__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getDeclarationAssignment_1()); }
	(rule__Root__DeclarationAssignment_1)
	{ after(grammarAccess.getRootAccess().getDeclarationAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getGroup_2()); }
	(rule__Root__Group_2__0)?
	{ after(grammarAccess.getRootAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Root__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group_2__0__Impl
	rule__Root__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getGreaterThanSignKeyword_2_0()); }
	'>'
	{ after(grammarAccess.getRootAccess().getGreaterThanSignKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getGroup_2_1()); }
	(rule__Root__Group_2_1__0)
	{ after(grammarAccess.getRootAccess().getGroup_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Root__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group_2_1__0__Impl
	rule__Root__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getObservedAssignment_2_1_0()); }
	(rule__Root__ObservedAssignment_2_1_0)
	{ after(grammarAccess.getRootAccess().getObservedAssignment_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getGroup_2_1_1()); }
	(rule__Root__Group_2_1_1__0)*
	{ after(grammarAccess.getRootAccess().getGroup_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Root__Group_2_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group_2_1_1__0__Impl
	rule__Root__Group_2_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getVerticalLineKeyword_2_1_1_0()); }
	'|'
	{ after(grammarAccess.getRootAccess().getVerticalLineKeyword_2_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Root__Group_2_1_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__Group_2_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRootAccess().getObservedAssignment_2_1_1_1()); }
	(rule__Root__ObservedAssignment_2_1_1_1)
	{ after(grammarAccess.getRootAccess().getObservedAssignment_2_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ImportDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ImportDeclaration__Group__0__Impl
	rule__ImportDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ImportDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImportDeclarationAccess().getIncludeKeyword_0()); }
	'#include'
	{ after(grammarAccess.getImportDeclarationAccess().getIncludeKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ImportDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ImportDeclaration__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ImportDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImportDeclarationAccess().getImportURIAssignment_1()); }
	(rule__ImportDeclaration__ImportURIAssignment_1)
	{ after(grammarAccess.getImportDeclarationAccess().getImportURIAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group__0__Impl
	rule__FunctionDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getFunctionKeyword_0()); }
	'function'
	{ after(grammarAccess.getFunctionDeclarationAccess().getFunctionKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group__1__Impl
	rule__FunctionDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getNameAssignment_1()); }
	(rule__FunctionDeclaration__NameAssignment_1)
	{ after(grammarAccess.getFunctionDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group__2__Impl
	rule__FunctionDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getGroup_2()); }
	(rule__FunctionDeclaration__Group_2__0)
	{ after(grammarAccess.getFunctionDeclarationAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group__3__Impl
	rule__FunctionDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getColonKeyword_3()); }
	':'
	{ after(grammarAccess.getFunctionDeclarationAccess().getColonKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group__4__Impl
	rule__FunctionDeclaration__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getTypeAssignment_4()); }
	(rule__FunctionDeclaration__TypeAssignment_4)
	{ after(grammarAccess.getFunctionDeclarationAccess().getTypeAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group__5__Impl
	rule__FunctionDeclaration__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getIsKeyword_5()); }
	'is'
	{ after(grammarAccess.getFunctionDeclarationAccess().getIsKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group__6__Impl
	rule__FunctionDeclaration__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__6__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getGroup_6()); }
	(rule__FunctionDeclaration__Group_6__0)?
	{ after(grammarAccess.getFunctionDeclarationAccess().getGroup_6()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__7
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group__7__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group__7__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getStatementAssignment_7()); }
	(rule__FunctionDeclaration__StatementAssignment_7)
	{ after(grammarAccess.getFunctionDeclarationAccess().getStatementAssignment_7()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDeclaration__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_2__0__Impl
	rule__FunctionDeclaration__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getLeftParenthesisKeyword_2_0()); }
	'('
	{ after(grammarAccess.getFunctionDeclarationAccess().getLeftParenthesisKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_2__1__Impl
	rule__FunctionDeclaration__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getGroup_2_1()); }
	(rule__FunctionDeclaration__Group_2_1__0)?
	{ after(grammarAccess.getFunctionDeclarationAccess().getGroup_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_2__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getRightParenthesisKeyword_2_2()); }
	')'
	{ after(grammarAccess.getFunctionDeclarationAccess().getRightParenthesisKeyword_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDeclaration__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_2_1__0__Impl
	rule__FunctionDeclaration__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getParametersAssignment_2_1_0()); }
	(rule__FunctionDeclaration__ParametersAssignment_2_1_0)
	{ after(grammarAccess.getFunctionDeclarationAccess().getParametersAssignment_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getGroup_2_1_1()); }
	(rule__FunctionDeclaration__Group_2_1_1__0)*
	{ after(grammarAccess.getFunctionDeclarationAccess().getGroup_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDeclaration__Group_2_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_2_1_1__0__Impl
	rule__FunctionDeclaration__Group_2_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getCommaKeyword_2_1_1_0()); }
	','
	{ after(grammarAccess.getFunctionDeclarationAccess().getCommaKeyword_2_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_2_1_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_2_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getParametersAssignment_2_1_1_1()); }
	(rule__FunctionDeclaration__ParametersAssignment_2_1_1_1)
	{ after(grammarAccess.getFunctionDeclarationAccess().getParametersAssignment_2_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDeclaration__Group_6__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_6__0__Impl
	rule__FunctionDeclaration__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_6__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getVarKeyword_6_0()); }
	'var'
	{ after(grammarAccess.getFunctionDeclarationAccess().getVarKeyword_6_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_6__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_6__1__Impl
	rule__FunctionDeclaration__Group_6__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_6__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getVariablesAssignment_6_1()); }
	(rule__FunctionDeclaration__VariablesAssignment_6_1)
	{ after(grammarAccess.getFunctionDeclarationAccess().getVariablesAssignment_6_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_6__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_6__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_6__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getGroup_6_2()); }
	(rule__FunctionDeclaration__Group_6_2__0)*
	{ after(grammarAccess.getFunctionDeclarationAccess().getGroup_6_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDeclaration__Group_6_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_6_2__0__Impl
	rule__FunctionDeclaration__Group_6_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_6_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getCommaKeyword_6_2_0()); }
	','
	{ after(grammarAccess.getFunctionDeclarationAccess().getCommaKeyword_6_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_6_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDeclaration__Group_6_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__Group_6_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDeclarationAccess().getVariablesAssignment_6_2_1()); }
	(rule__FunctionDeclaration__VariablesAssignment_6_2_1)
	{ after(grammarAccess.getFunctionDeclarationAccess().getVariablesAssignment_6_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TypeDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypeDeclaration__Group__0__Impl
	rule__TypeDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypeDeclarationAccess().getTypeKeyword_0()); }
	'type'
	{ after(grammarAccess.getTypeDeclarationAccess().getTypeKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypeDeclaration__Group__1__Impl
	rule__TypeDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypeDeclarationAccess().getNameAssignment_1()); }
	(rule__TypeDeclaration__NameAssignment_1)
	{ after(grammarAccess.getTypeDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypeDeclaration__Group__2__Impl
	rule__TypeDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypeDeclarationAccess().getIsKeyword_2()); }
	'is'
	{ after(grammarAccess.getTypeDeclarationAccess().getIsKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypeDeclaration__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypeDeclarationAccess().getValueAssignment_3()); }
	(rule__TypeDeclaration__ValueAssignment_3)
	{ after(grammarAccess.getTypeDeclarationAccess().getValueAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ChannelDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelDeclaration__Group__0__Impl
	rule__ChannelDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelDeclarationAccess().getChannelKeyword_0()); }
	'channel'
	{ after(grammarAccess.getChannelDeclarationAccess().getChannelKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelDeclaration__Group__1__Impl
	rule__ChannelDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelDeclarationAccess().getNameAssignment_1()); }
	(rule__ChannelDeclaration__NameAssignment_1)
	{ after(grammarAccess.getChannelDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelDeclaration__Group__2__Impl
	rule__ChannelDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelDeclarationAccess().getIsKeyword_2()); }
	'is'
	{ after(grammarAccess.getChannelDeclarationAccess().getIsKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelDeclaration__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelDeclarationAccess().getValueAssignment_3()); }
	(rule__ChannelDeclaration__ValueAssignment_3)
	{ after(grammarAccess.getChannelDeclarationAccess().getValueAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ChannelType__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group__0__Impl
	rule__ChannelType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getChannelTypeAction_0()); }
	()
	{ after(grammarAccess.getChannelTypeAccess().getChannelTypeAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group__1__Impl
	rule__ChannelType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getGroup_1()); }
	(rule__ChannelType__Group_1__0)?
	{ after(grammarAccess.getChannelTypeAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getAlternatives_2()); }
	(rule__ChannelType__Alternatives_2)
	{ after(grammarAccess.getChannelTypeAccess().getAlternatives_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ChannelType__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group_1__0__Impl
	rule__ChannelType__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getArrayKeyword_1_0()); }
	'array'
	{ after(grammarAccess.getChannelTypeAccess().getArrayKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group_1__1__Impl
	rule__ChannelType__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getSizeAssignment_1_1()); }
	(rule__ChannelType__SizeAssignment_1_1)
	{ after(grammarAccess.getChannelTypeAccess().getSizeAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getOfKeyword_1_2()); }
	'of'
	{ after(grammarAccess.getChannelTypeAccess().getOfKeyword_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ChannelType__Group_2_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group_2_0__0__Impl
	rule__ChannelType__Group_2_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_2_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getAlternatives_2_0_0()); }
	(rule__ChannelType__Alternatives_2_0_0)?
	{ after(grammarAccess.getChannelTypeAccess().getAlternatives_2_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_2_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group_2_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_2_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getAlternatives_2_0_1()); }
	(rule__ChannelType__Alternatives_2_0_1)
	{ after(grammarAccess.getChannelTypeAccess().getAlternatives_2_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ChannelType__Group_2_0_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group_2_0_0_0__0__Impl
	rule__ChannelType__Group_2_0_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_2_0_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getInAssignment_2_0_0_0_0()); }
	(rule__ChannelType__InAssignment_2_0_0_0_0)
	{ after(grammarAccess.getChannelTypeAccess().getInAssignment_2_0_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_2_0_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ChannelType__Group_2_0_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__Group_2_0_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getChannelTypeAccess().getOutAssignment_2_0_0_0_1()); }
	(rule__ChannelType__OutAssignment_2_0_0_0_1)?
	{ after(grammarAccess.getChannelTypeAccess().getOutAssignment_2_0_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TupleType__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TupleType__Group__0__Impl
	rule__TupleType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTupleTypeAccess().getTypeParserRuleCall_0()); }
	ruleType
	{ after(grammarAccess.getTupleTypeAccess().getTypeParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TupleType__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTupleTypeAccess().getGroup_1()); }
	(rule__TupleType__Group_1__0)*
	{ after(grammarAccess.getTupleTypeAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TupleType__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TupleType__Group_1__0__Impl
	rule__TupleType__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTupleTypeAccess().getTupleTypeTypesAction_1_0()); }
	()
	{ after(grammarAccess.getTupleTypeAccess().getTupleTypeTypesAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TupleType__Group_1__1__Impl
	rule__TupleType__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTupleTypeAccess().getNumberSignKeyword_1_1()); }
	'#'
	{ after(grammarAccess.getTupleTypeAccess().getNumberSignKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TupleType__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTupleTypeAccess().getTypesAssignment_1_2()); }
	(rule__TupleType__TypesAssignment_1_2)
	{ after(grammarAccess.getTupleTypeAccess().getTypesAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BasicType__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BasicType__Group_0__0__Impl
	rule__BasicType__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBasicTypeAccess().getNaturalTypeAction_0_0()); }
	()
	{ after(grammarAccess.getBasicTypeAccess().getNaturalTypeAction_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BasicType__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBasicTypeAccess().getNatKeyword_0_1()); }
	'nat'
	{ after(grammarAccess.getBasicTypeAccess().getNatKeyword_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BasicType__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BasicType__Group_1__0__Impl
	rule__BasicType__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBasicTypeAccess().getIntegerTypeAction_1_0()); }
	()
	{ after(grammarAccess.getBasicTypeAccess().getIntegerTypeAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BasicType__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBasicTypeAccess().getIntKeyword_1_1()); }
	'int'
	{ after(grammarAccess.getBasicTypeAccess().getIntKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BasicType__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BasicType__Group_2__0__Impl
	rule__BasicType__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBasicTypeAccess().getBooleanTypeAction_2_0()); }
	()
	{ after(grammarAccess.getBasicTypeAccess().getBooleanTypeAction_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BasicType__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BasicType__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBasicTypeAccess().getBoolKeyword_2_1()); }
	'bool'
	{ after(grammarAccess.getBasicTypeAccess().getBoolKeyword_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__RangeType__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RangeType__Group__0__Impl
	rule__RangeType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeType__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRangeTypeAccess().getMinimumAssignment_0()); }
	(rule__RangeType__MinimumAssignment_0)
	{ after(grammarAccess.getRangeTypeAccess().getMinimumAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeType__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RangeType__Group__1__Impl
	rule__RangeType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeType__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRangeTypeAccess().getFullStopFullStopKeyword_1()); }
	'..'
	{ after(grammarAccess.getRangeTypeAccess().getFullStopFullStopKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeType__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RangeType__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeType__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRangeTypeAccess().getMaximumAssignment_2()); }
	(rule__RangeType__MaximumAssignment_2)
	{ after(grammarAccess.getRangeTypeAccess().getMaximumAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnionType__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionType__Group__0__Impl
	rule__UnionType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTypeAccess().getUnionKeyword_0()); }
	'union'
	{ after(grammarAccess.getUnionTypeAccess().getUnionKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionType__Group__1__Impl
	rule__UnionType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTypeAccess().getTagsAssignment_1()); }
	(rule__UnionType__TagsAssignment_1)
	{ after(grammarAccess.getUnionTypeAccess().getTagsAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionType__Group__2__Impl
	rule__UnionType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTypeAccess().getGroup_2()); }
	(rule__UnionType__Group_2__0)*
	{ after(grammarAccess.getUnionTypeAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionType__Group__3__Impl
	rule__UnionType__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTypeAccess().getEndKeyword_3()); }
	'end'
	{ after(grammarAccess.getUnionTypeAccess().getEndKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionType__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTypeAccess().getUnionKeyword_4()); }
	('union')?
	{ after(grammarAccess.getUnionTypeAccess().getUnionKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnionType__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionType__Group_2__0__Impl
	rule__UnionType__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTypeAccess().getVerticalLineKeyword_2_0()); }
	'|'
	{ after(grammarAccess.getUnionTypeAccess().getVerticalLineKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionType__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTypeAccess().getTagsAssignment_2_1()); }
	(rule__UnionType__TagsAssignment_2_1)
	{ after(grammarAccess.getUnionTypeAccess().getTagsAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnionTags__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionTags__Group__0__Impl
	rule__UnionTags__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTagsAccess().getTagsAssignment_0()); }
	(rule__UnionTags__TagsAssignment_0)
	{ after(grammarAccess.getUnionTagsAccess().getTagsAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionTags__Group__1__Impl
	rule__UnionTags__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTagsAccess().getGroup_1()); }
	(rule__UnionTags__Group_1__0)*
	{ after(grammarAccess.getUnionTagsAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionTags__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTagsAccess().getGroup_2()); }
	(rule__UnionTags__Group_2__0)?
	{ after(grammarAccess.getUnionTagsAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnionTags__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionTags__Group_1__0__Impl
	rule__UnionTags__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTagsAccess().getCommaKeyword_1_0()); }
	','
	{ after(grammarAccess.getUnionTagsAccess().getCommaKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionTags__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTagsAccess().getTagsAssignment_1_1()); }
	(rule__UnionTags__TagsAssignment_1_1)
	{ after(grammarAccess.getUnionTagsAccess().getTagsAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnionTags__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionTags__Group_2__0__Impl
	rule__UnionTags__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTagsAccess().getOfKeyword_2_0()); }
	'of'
	{ after(grammarAccess.getUnionTagsAccess().getOfKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnionTags__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnionTagsAccess().getTypeAssignment_2_1()); }
	(rule__UnionTags__TypeAssignment_2_1)
	{ after(grammarAccess.getUnionTagsAccess().getTypeAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__RecordType__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordType__Group__0__Impl
	rule__RecordType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordTypeAccess().getRecordKeyword_0()); }
	'record'
	{ after(grammarAccess.getRecordTypeAccess().getRecordKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordType__Group__1__Impl
	rule__RecordType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordTypeAccess().getFieldsAssignment_1()); }
	(rule__RecordType__FieldsAssignment_1)
	{ after(grammarAccess.getRecordTypeAccess().getFieldsAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordType__Group__2__Impl
	rule__RecordType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordTypeAccess().getGroup_2()); }
	(rule__RecordType__Group_2__0)*
	{ after(grammarAccess.getRecordTypeAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordType__Group__3__Impl
	rule__RecordType__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordTypeAccess().getEndKeyword_3()); }
	'end'
	{ after(grammarAccess.getRecordTypeAccess().getEndKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordType__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordTypeAccess().getRecordKeyword_4()); }
	('record')?
	{ after(grammarAccess.getRecordTypeAccess().getRecordKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__RecordType__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordType__Group_2__0__Impl
	rule__RecordType__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordTypeAccess().getCommaKeyword_2_0()); }
	','
	{ after(grammarAccess.getRecordTypeAccess().getCommaKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordType__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordTypeAccess().getFieldsAssignment_2_1()); }
	(rule__RecordType__FieldsAssignment_2_1)
	{ after(grammarAccess.getRecordTypeAccess().getFieldsAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__RecordFields__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordFields__Group__0__Impl
	rule__RecordFields__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordFieldsAccess().getFieldsAssignment_0()); }
	(rule__RecordFields__FieldsAssignment_0)
	{ after(grammarAccess.getRecordFieldsAccess().getFieldsAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordFields__Group__1__Impl
	rule__RecordFields__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordFieldsAccess().getGroup_1()); }
	(rule__RecordFields__Group_1__0)*
	{ after(grammarAccess.getRecordFieldsAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordFields__Group__2__Impl
	rule__RecordFields__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordFieldsAccess().getColonKeyword_2()); }
	':'
	{ after(grammarAccess.getRecordFieldsAccess().getColonKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordFields__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordFieldsAccess().getTypeAssignment_3()); }
	(rule__RecordFields__TypeAssignment_3)
	{ after(grammarAccess.getRecordFieldsAccess().getTypeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__RecordFields__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordFields__Group_1__0__Impl
	rule__RecordFields__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordFieldsAccess().getCommaKeyword_1_0()); }
	','
	{ after(grammarAccess.getRecordFieldsAccess().getCommaKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordFields__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordFieldsAccess().getFieldsAssignment_1_1()); }
	(rule__RecordFields__FieldsAssignment_1_1)
	{ after(grammarAccess.getRecordFieldsAccess().getFieldsAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QueueType__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueType__Group__0__Impl
	rule__QueueType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueTypeAccess().getQueueKeyword_0()); }
	'queue'
	{ after(grammarAccess.getQueueTypeAccess().getQueueKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueType__Group__1__Impl
	rule__QueueType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueTypeAccess().getSizeAssignment_1()); }
	(rule__QueueType__SizeAssignment_1)
	{ after(grammarAccess.getQueueTypeAccess().getSizeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueType__Group__2__Impl
	rule__QueueType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueTypeAccess().getOfKeyword_2()); }
	'of'
	{ after(grammarAccess.getQueueTypeAccess().getOfKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueType__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueTypeAccess().getTypeAssignment_3()); }
	(rule__QueueType__TypeAssignment_3)
	{ after(grammarAccess.getQueueTypeAccess().getTypeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayType__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayType__Group__0__Impl
	rule__ArrayType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayTypeAccess().getArrayKeyword_0()); }
	'array'
	{ after(grammarAccess.getArrayTypeAccess().getArrayKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayType__Group__1__Impl
	rule__ArrayType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayTypeAccess().getSizeAssignment_1()); }
	(rule__ArrayType__SizeAssignment_1)
	{ after(grammarAccess.getArrayTypeAccess().getSizeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayType__Group__2__Impl
	rule__ArrayType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayTypeAccess().getOfKeyword_2()); }
	'of'
	{ after(grammarAccess.getArrayTypeAccess().getOfKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayType__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayTypeAccess().getTypeAssignment_3()); }
	(rule__ArrayType__TypeAssignment_3)
	{ after(grammarAccess.getArrayTypeAccess().getTypeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ConstantDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConstantDeclaration__Group__0__Impl
	rule__ConstantDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConstantDeclarationAccess().getConstKeyword_0()); }
	'const'
	{ after(grammarAccess.getConstantDeclarationAccess().getConstKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConstantDeclaration__Group__1__Impl
	rule__ConstantDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConstantDeclarationAccess().getNameAssignment_1()); }
	(rule__ConstantDeclaration__NameAssignment_1)
	{ after(grammarAccess.getConstantDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConstantDeclaration__Group__2__Impl
	rule__ConstantDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConstantDeclarationAccess().getColonKeyword_2()); }
	':'
	{ after(grammarAccess.getConstantDeclarationAccess().getColonKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConstantDeclaration__Group__3__Impl
	rule__ConstantDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConstantDeclarationAccess().getTypeAssignment_3()); }
	(rule__ConstantDeclaration__TypeAssignment_3)
	{ after(grammarAccess.getConstantDeclarationAccess().getTypeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConstantDeclaration__Group__4__Impl
	rule__ConstantDeclaration__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConstantDeclarationAccess().getIsKeyword_4()); }
	'is'
	{ after(grammarAccess.getConstantDeclarationAccess().getIsKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConstantDeclaration__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConstantDeclarationAccess().getValueAssignment_5()); }
	(rule__ConstantDeclaration__ValueAssignment_5)
	{ after(grammarAccess.getConstantDeclarationAccess().getValueAssignment_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__0__Impl
	rule__ProcessDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getProcessKeyword_0()); }
	'process'
	{ after(grammarAccess.getProcessDeclarationAccess().getProcessKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__1__Impl
	rule__ProcessDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getNameAssignment_1()); }
	(rule__ProcessDeclaration__NameAssignment_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__2__Impl
	rule__ProcessDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_2()); }
	(rule__ProcessDeclaration__Group_2__0)?
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__3__Impl
	rule__ProcessDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_3()); }
	(rule__ProcessDeclaration__Group_3__0)?
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__4__Impl
	rule__ProcessDeclaration__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getIsKeyword_4()); }
	'is'
	{ after(grammarAccess.getProcessDeclarationAccess().getIsKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__5__Impl
	rule__ProcessDeclaration__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_5()); }
	(rule__ProcessDeclaration__Group_5__0)?
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__6__Impl
	rule__ProcessDeclaration__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__6__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_6()); }
	(rule__ProcessDeclaration__Group_6__0)?
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_6()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__7
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__7__Impl
	rule__ProcessDeclaration__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__7__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getStatesKeyword_7()); }
	'states'
	{ after(grammarAccess.getProcessDeclarationAccess().getStatesKeyword_7()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__8
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__8__Impl
	rule__ProcessDeclaration__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__8__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getStatesAssignment_8()); }
	(rule__ProcessDeclaration__StatesAssignment_8)
	{ after(grammarAccess.getProcessDeclarationAccess().getStatesAssignment_8()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__9
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__9__Impl
	rule__ProcessDeclaration__Group__10
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__9__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_9()); }
	(rule__ProcessDeclaration__Group_9__0)*
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_9()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__10
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__10__Impl
	rule__ProcessDeclaration__Group__11
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__10__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_10()); }
	(rule__ProcessDeclaration__Group_10__0)?
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_10()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__11
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__11__Impl
	rule__ProcessDeclaration__Group__12
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__11__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_11()); }
	(rule__ProcessDeclaration__Group_11__0)?
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_11()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__12
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group__12__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group__12__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getTransitionsAssignment_12()); }
		(rule__ProcessDeclaration__TransitionsAssignment_12)
		{ after(grammarAccess.getProcessDeclarationAccess().getTransitionsAssignment_12()); }
	)
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getTransitionsAssignment_12()); }
		(rule__ProcessDeclaration__TransitionsAssignment_12)*
		{ after(grammarAccess.getProcessDeclarationAccess().getTransitionsAssignment_12()); }
	)
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_2__0__Impl
	rule__ProcessDeclaration__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getLeftSquareBracketKeyword_2_0()); }
	'['
	{ after(grammarAccess.getProcessDeclarationAccess().getLeftSquareBracketKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_2__1__Impl
	rule__ProcessDeclaration__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getPortsAssignment_2_1()); }
	(rule__ProcessDeclaration__PortsAssignment_2_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getPortsAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_2__2__Impl
	rule__ProcessDeclaration__Group_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_2_2()); }
	(rule__ProcessDeclaration__Group_2_2__0)*
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getRightSquareBracketKeyword_2_3()); }
	']'
	{ after(grammarAccess.getProcessDeclarationAccess().getRightSquareBracketKeyword_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_2_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_2_2__0__Impl
	rule__ProcessDeclaration__Group_2_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_2_2_0()); }
	','
	{ after(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_2_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_2_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_2_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getPortsAssignment_2_2_1()); }
	(rule__ProcessDeclaration__PortsAssignment_2_2_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getPortsAssignment_2_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_3__0__Impl
	rule__ProcessDeclaration__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getLeftParenthesisKeyword_3_0()); }
	'('
	{ after(grammarAccess.getProcessDeclarationAccess().getLeftParenthesisKeyword_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_3__1__Impl
	rule__ProcessDeclaration__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getParametersAssignment_3_1()); }
	(rule__ProcessDeclaration__ParametersAssignment_3_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getParametersAssignment_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_3__2__Impl
	rule__ProcessDeclaration__Group_3__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_3_2()); }
	(rule__ProcessDeclaration__Group_3_2__0)*
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_3__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getRightParenthesisKeyword_3_3()); }
	')'
	{ after(grammarAccess.getProcessDeclarationAccess().getRightParenthesisKeyword_3_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_3_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_3_2__0__Impl
	rule__ProcessDeclaration__Group_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_3_2_0()); }
	','
	{ after(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_3_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_3_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_3_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getParametersAssignment_3_2_1()); }
	(rule__ProcessDeclaration__ParametersAssignment_3_2_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getParametersAssignment_3_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_5__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_5__0__Impl
	rule__ProcessDeclaration__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_5__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getPortKeyword_5_0()); }
	'port'
	{ after(grammarAccess.getProcessDeclarationAccess().getPortKeyword_5_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_5__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_5__1__Impl
	rule__ProcessDeclaration__Group_5__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_5__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getLocalPortsAssignment_5_1()); }
	(rule__ProcessDeclaration__LocalPortsAssignment_5_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getLocalPortsAssignment_5_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_5__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_5__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_5__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_5_2()); }
	(rule__ProcessDeclaration__Group_5_2__0)*
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_5_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_5_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_5_2__0__Impl
	rule__ProcessDeclaration__Group_5_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_5_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_5_2_0()); }
	','
	{ after(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_5_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_5_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_5_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_5_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getLocalPortsAssignment_5_2_1()); }
	(rule__ProcessDeclaration__LocalPortsAssignment_5_2_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getLocalPortsAssignment_5_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_6__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_6__0__Impl
	rule__ProcessDeclaration__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_6__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getPriorityKeyword_6_0()); }
	'priority'
	{ after(grammarAccess.getProcessDeclarationAccess().getPriorityKeyword_6_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_6__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_6__1__Impl
	rule__ProcessDeclaration__Group_6__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_6__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getPrioritiesAssignment_6_1()); }
	(rule__ProcessDeclaration__PrioritiesAssignment_6_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getPrioritiesAssignment_6_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_6__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_6__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_6__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_6_2()); }
	(rule__ProcessDeclaration__Group_6_2__0)*
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_6_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_6_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_6_2__0__Impl
	rule__ProcessDeclaration__Group_6_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_6_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_6_2_0()); }
	','
	{ after(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_6_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_6_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_6_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_6_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getPrioritiesAssignment_6_2_1()); }
	(rule__ProcessDeclaration__PrioritiesAssignment_6_2_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getPrioritiesAssignment_6_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_9__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_9__0__Impl
	rule__ProcessDeclaration__Group_9__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_9__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_9_0()); }
	','
	{ after(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_9_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_9__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_9__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_9__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getStatesAssignment_9_1()); }
	(rule__ProcessDeclaration__StatesAssignment_9_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getStatesAssignment_9_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_10__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_10__0__Impl
	rule__ProcessDeclaration__Group_10__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_10__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getVarKeyword_10_0()); }
	'var'
	{ after(grammarAccess.getProcessDeclarationAccess().getVarKeyword_10_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_10__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_10__1__Impl
	rule__ProcessDeclaration__Group_10__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_10__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getVariablesAssignment_10_1()); }
	(rule__ProcessDeclaration__VariablesAssignment_10_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getVariablesAssignment_10_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_10__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_10__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_10__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getGroup_10_2()); }
	(rule__ProcessDeclaration__Group_10_2__0)*
	{ after(grammarAccess.getProcessDeclarationAccess().getGroup_10_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_10_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_10_2__0__Impl
	rule__ProcessDeclaration__Group_10_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_10_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_10_2_0()); }
	','
	{ after(grammarAccess.getProcessDeclarationAccess().getCommaKeyword_10_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_10_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_10_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_10_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getVariablesAssignment_10_2_1()); }
	(rule__ProcessDeclaration__VariablesAssignment_10_2_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getVariablesAssignment_10_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ProcessDeclaration__Group_11__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_11__0__Impl
	rule__ProcessDeclaration__Group_11__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_11__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getInitKeyword_11_0()); }
	'init'
	{ after(grammarAccess.getProcessDeclarationAccess().getInitKeyword_11_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_11__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ProcessDeclaration__Group_11__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__Group_11__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProcessDeclarationAccess().getPreludeAssignment_11_1()); }
	(rule__ProcessDeclaration__PreludeAssignment_11_1)
	{ after(grammarAccess.getProcessDeclarationAccess().getPreludeAssignment_11_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TransitionSource__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TransitionSource__Group__0__Impl
	rule__TransitionSource__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionSource__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTransitionSourceAccess().getFromKeyword_0()); }
	'from'
	{ after(grammarAccess.getTransitionSourceAccess().getFromKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionSource__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TransitionSource__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionSource__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTransitionSourceAccess().getOriginAssignment_1()); }
	(rule__TransitionSource__OriginAssignment_1)
	{ after(grammarAccess.getTransitionSourceAccess().getOriginAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Transition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Transition__Group__0__Impl
	rule__Transition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Transition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTransitionAccess().getSourceAssignment_0()); }
	(rule__Transition__SourceAssignment_0)
	{ after(grammarAccess.getTransitionAccess().getSourceAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Transition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Transition__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Transition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTransitionAccess().getActionAssignment_1()); }
	(rule__Transition__ActionAssignment_1)
	{ after(grammarAccess.getTransitionAccess().getActionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__0__Impl
	rule__ComponentDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getComponentKeyword_0()); }
	'component'
	{ after(grammarAccess.getComponentDeclarationAccess().getComponentKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__1__Impl
	rule__ComponentDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getNameAssignment_1()); }
	(rule__ComponentDeclaration__NameAssignment_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__2__Impl
	rule__ComponentDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_2()); }
	(rule__ComponentDeclaration__Group_2__0)?
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__3__Impl
	rule__ComponentDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_3()); }
	(rule__ComponentDeclaration__Group_3__0)?
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__4__Impl
	rule__ComponentDeclaration__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getIsKeyword_4()); }
	'is'
	{ after(grammarAccess.getComponentDeclarationAccess().getIsKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__5__Impl
	rule__ComponentDeclaration__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_5()); }
	(rule__ComponentDeclaration__Group_5__0)?
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__6__Impl
	rule__ComponentDeclaration__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__6__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_6()); }
	(rule__ComponentDeclaration__Group_6__0)?
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_6()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__7
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__7__Impl
	rule__ComponentDeclaration__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__7__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_7()); }
	(rule__ComponentDeclaration__Group_7__0)?
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_7()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__8
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__8__Impl
	rule__ComponentDeclaration__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__8__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_8()); }
	(rule__ComponentDeclaration__Group_8__0)?
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_8()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__9
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group__9__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group__9__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getBodyAssignment_9()); }
	(rule__ComponentDeclaration__BodyAssignment_9)
	{ after(grammarAccess.getComponentDeclarationAccess().getBodyAssignment_9()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_2__0__Impl
	rule__ComponentDeclaration__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getLeftSquareBracketKeyword_2_0()); }
	'['
	{ after(grammarAccess.getComponentDeclarationAccess().getLeftSquareBracketKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_2__1__Impl
	rule__ComponentDeclaration__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getPortsAssignment_2_1()); }
	(rule__ComponentDeclaration__PortsAssignment_2_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getPortsAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_2__2__Impl
	rule__ComponentDeclaration__Group_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_2_2()); }
	(rule__ComponentDeclaration__Group_2_2__0)*
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getRightSquareBracketKeyword_2_3()); }
	']'
	{ after(grammarAccess.getComponentDeclarationAccess().getRightSquareBracketKeyword_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_2_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_2_2__0__Impl
	rule__ComponentDeclaration__Group_2_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_2_2_0()); }
	','
	{ after(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_2_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_2_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_2_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getPortsAssignment_2_2_1()); }
	(rule__ComponentDeclaration__PortsAssignment_2_2_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getPortsAssignment_2_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_3__0__Impl
	rule__ComponentDeclaration__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getLeftParenthesisKeyword_3_0()); }
	'('
	{ after(grammarAccess.getComponentDeclarationAccess().getLeftParenthesisKeyword_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_3__1__Impl
	rule__ComponentDeclaration__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getParametersAssignment_3_1()); }
	(rule__ComponentDeclaration__ParametersAssignment_3_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getParametersAssignment_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_3__2__Impl
	rule__ComponentDeclaration__Group_3__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_3_2()); }
	(rule__ComponentDeclaration__Group_3_2__0)*
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_3__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getRightParenthesisKeyword_3_3()); }
	')'
	{ after(grammarAccess.getComponentDeclarationAccess().getRightParenthesisKeyword_3_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_3_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_3_2__0__Impl
	rule__ComponentDeclaration__Group_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_3_2_0()); }
	','
	{ after(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_3_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_3_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_3_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getParametersAssignment_3_2_1()); }
	(rule__ComponentDeclaration__ParametersAssignment_3_2_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getParametersAssignment_3_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_5__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_5__0__Impl
	rule__ComponentDeclaration__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_5__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getVarKeyword_5_0()); }
	'var'
	{ after(grammarAccess.getComponentDeclarationAccess().getVarKeyword_5_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_5__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_5__1__Impl
	rule__ComponentDeclaration__Group_5__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_5__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getVariablesAssignment_5_1()); }
	(rule__ComponentDeclaration__VariablesAssignment_5_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getVariablesAssignment_5_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_5__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_5__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_5__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_5_2()); }
	(rule__ComponentDeclaration__Group_5_2__0)*
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_5_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_5_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_5_2__0__Impl
	rule__ComponentDeclaration__Group_5_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_5_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_5_2_0()); }
	','
	{ after(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_5_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_5_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_5_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_5_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getVariablesAssignment_5_2_1()); }
	(rule__ComponentDeclaration__VariablesAssignment_5_2_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getVariablesAssignment_5_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_6__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_6__0__Impl
	rule__ComponentDeclaration__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_6__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getPortKeyword_6_0()); }
	'port'
	{ after(grammarAccess.getComponentDeclarationAccess().getPortKeyword_6_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_6__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_6__1__Impl
	rule__ComponentDeclaration__Group_6__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_6__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getLocalPortsAssignment_6_1()); }
	(rule__ComponentDeclaration__LocalPortsAssignment_6_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getLocalPortsAssignment_6_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_6__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_6__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_6__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_6_2()); }
	(rule__ComponentDeclaration__Group_6_2__0)*
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_6_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_6_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_6_2__0__Impl
	rule__ComponentDeclaration__Group_6_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_6_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_6_2_0()); }
	','
	{ after(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_6_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_6_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_6_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_6_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getLocalPortsAssignment_6_2_1()); }
	(rule__ComponentDeclaration__LocalPortsAssignment_6_2_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getLocalPortsAssignment_6_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_7__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_7__0__Impl
	rule__ComponentDeclaration__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_7__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getPriorityKeyword_7_0()); }
	'priority'
	{ after(grammarAccess.getComponentDeclarationAccess().getPriorityKeyword_7_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_7__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_7__1__Impl
	rule__ComponentDeclaration__Group_7__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_7__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getPrioritiesAssignment_7_1()); }
	(rule__ComponentDeclaration__PrioritiesAssignment_7_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getPrioritiesAssignment_7_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_7__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_7__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_7__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getGroup_7_2()); }
	(rule__ComponentDeclaration__Group_7_2__0)*
	{ after(grammarAccess.getComponentDeclarationAccess().getGroup_7_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_7_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_7_2__0__Impl
	rule__ComponentDeclaration__Group_7_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_7_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_7_2_0()); }
	','
	{ after(grammarAccess.getComponentDeclarationAccess().getCommaKeyword_7_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_7_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_7_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_7_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getPrioritiesAssignment_7_2_1()); }
	(rule__ComponentDeclaration__PrioritiesAssignment_7_2_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getPrioritiesAssignment_7_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentDeclaration__Group_8__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_8__0__Impl
	rule__ComponentDeclaration__Group_8__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_8__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getInitKeyword_8_0()); }
	'init'
	{ after(grammarAccess.getComponentDeclarationAccess().getInitKeyword_8_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_8__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentDeclaration__Group_8__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__Group_8__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentDeclarationAccess().getPreludeAssignment_8_1()); }
	(rule__ComponentDeclaration__PreludeAssignment_8_1)
	{ after(grammarAccess.getComponentDeclarationAccess().getPreludeAssignment_8_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PortsDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortsDeclaration__Group__0__Impl
	rule__PortsDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortsDeclarationAccess().getPortsAssignment_0()); }
	(rule__PortsDeclaration__PortsAssignment_0)
	{ after(grammarAccess.getPortsDeclarationAccess().getPortsAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortsDeclaration__Group__1__Impl
	rule__PortsDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortsDeclarationAccess().getGroup_1()); }
	(rule__PortsDeclaration__Group_1__0)*
	{ after(grammarAccess.getPortsDeclarationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortsDeclaration__Group__2__Impl
	rule__PortsDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortsDeclarationAccess().getColonKeyword_2()); }
	':'
	{ after(grammarAccess.getPortsDeclarationAccess().getColonKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortsDeclaration__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortsDeclarationAccess().getTypeAssignment_3()); }
	(rule__PortsDeclaration__TypeAssignment_3)
	{ after(grammarAccess.getPortsDeclarationAccess().getTypeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PortsDeclaration__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortsDeclaration__Group_1__0__Impl
	rule__PortsDeclaration__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortsDeclarationAccess().getCommaKeyword_1_0()); }
	','
	{ after(grammarAccess.getPortsDeclarationAccess().getCommaKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortsDeclaration__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortsDeclarationAccess().getPortsAssignment_1_1()); }
	(rule__PortsDeclaration__PortsAssignment_1_1)
	{ after(grammarAccess.getPortsDeclarationAccess().getPortsAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LocalPortsDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group__0__Impl
	rule__LocalPortsDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getPortsAssignment_0()); }
	(rule__LocalPortsDeclaration__PortsAssignment_0)
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getPortsAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group__1__Impl
	rule__LocalPortsDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getGroup_1()); }
	(rule__LocalPortsDeclaration__Group_1__0)*
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group__2__Impl
	rule__LocalPortsDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getColonKeyword_2()); }
	':'
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getColonKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group__3__Impl
	rule__LocalPortsDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getTypeAssignment_3()); }
	(rule__LocalPortsDeclaration__TypeAssignment_3)
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getTypeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getGroup_4()); }
	(rule__LocalPortsDeclaration__Group_4__0)?
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getGroup_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LocalPortsDeclaration__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group_1__0__Impl
	rule__LocalPortsDeclaration__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getCommaKeyword_1_0()); }
	','
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getCommaKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getPortsAssignment_1_1()); }
	(rule__LocalPortsDeclaration__PortsAssignment_1_1)
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getPortsAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LocalPortsDeclaration__Group_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group_4__0__Impl
	rule__LocalPortsDeclaration__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getInKeyword_4_0()); }
	'in'
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getInKeyword_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group_4__1__Impl
	rule__LocalPortsDeclaration__Group_4__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getLeftAssignment_4_1()); }
	(rule__LocalPortsDeclaration__LeftAssignment_4_1)
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getLeftAssignment_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_4__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group_4__2__Impl
	rule__LocalPortsDeclaration__Group_4__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_4__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getCommaKeyword_4_2()); }
	','
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getCommaKeyword_4_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_4__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LocalPortsDeclaration__Group_4__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__Group_4__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLocalPortsDeclarationAccess().getRightAssignment_4_3()); }
	(rule__LocalPortsDeclaration__RightAssignment_4_3)
	{ after(grammarAccess.getLocalPortsDeclarationAccess().getRightAssignment_4_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ParametersDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParametersDeclaration__Group__0__Impl
	rule__ParametersDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParametersDeclarationAccess().getParametersAssignment_0()); }
	(rule__ParametersDeclaration__ParametersAssignment_0)
	{ after(grammarAccess.getParametersDeclarationAccess().getParametersAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParametersDeclaration__Group__1__Impl
	rule__ParametersDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParametersDeclarationAccess().getGroup_1()); }
	(rule__ParametersDeclaration__Group_1__0)*
	{ after(grammarAccess.getParametersDeclarationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParametersDeclaration__Group__2__Impl
	rule__ParametersDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParametersDeclarationAccess().getColonKeyword_2()); }
	':'
	{ after(grammarAccess.getParametersDeclarationAccess().getColonKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParametersDeclaration__Group__3__Impl
	rule__ParametersDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParametersDeclarationAccess().getReadAssignment_3()); }
	(rule__ParametersDeclaration__ReadAssignment_3)?
	{ after(grammarAccess.getParametersDeclarationAccess().getReadAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParametersDeclaration__Group__4__Impl
	rule__ParametersDeclaration__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParametersDeclarationAccess().getWriteAssignment_4()); }
	(rule__ParametersDeclaration__WriteAssignment_4)?
	{ after(grammarAccess.getParametersDeclarationAccess().getWriteAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParametersDeclaration__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParametersDeclarationAccess().getTypeAssignment_5()); }
	(rule__ParametersDeclaration__TypeAssignment_5)
	{ after(grammarAccess.getParametersDeclarationAccess().getTypeAssignment_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ParametersDeclaration__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParametersDeclaration__Group_1__0__Impl
	rule__ParametersDeclaration__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParametersDeclarationAccess().getCommaKeyword_1_0()); }
	','
	{ after(grammarAccess.getParametersDeclarationAccess().getCommaKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParametersDeclaration__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParametersDeclarationAccess().getParametersAssignment_1_1()); }
	(rule__ParametersDeclaration__ParametersAssignment_1_1)
	{ after(grammarAccess.getParametersDeclarationAccess().getParametersAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ParameterDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParameterDeclaration__Group__0__Impl
	rule__ParameterDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParameterDeclarationAccess().getGroup_0()); }
	(rule__ParameterDeclaration__Group_0__0)?
	{ after(grammarAccess.getParameterDeclarationAccess().getGroup_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParameterDeclaration__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParameterDeclarationAccess().getNameAssignment_1()); }
	(rule__ParameterDeclaration__NameAssignment_1)
	{ after(grammarAccess.getParameterDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ParameterDeclaration__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParameterDeclaration__Group_0__0__Impl
	rule__ParameterDeclaration__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParameterDeclarationAccess().getReferenceAssignment_0_0()); }
	(rule__ParameterDeclaration__ReferenceAssignment_0_0)
	{ after(grammarAccess.getParameterDeclarationAccess().getReferenceAssignment_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParameterDeclaration__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParameterDeclarationAccess().getGroup_0_1()); }
	(rule__ParameterDeclaration__Group_0_1__0)?
	{ after(grammarAccess.getParameterDeclarationAccess().getGroup_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ParameterDeclaration__Group_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParameterDeclaration__Group_0_1__0__Impl
	rule__ParameterDeclaration__Group_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParameterDeclarationAccess().getArrayAssignment_0_1_0()); }
	(rule__ParameterDeclaration__ArrayAssignment_0_1_0)
	{ after(grammarAccess.getParameterDeclarationAccess().getArrayAssignment_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParameterDeclaration__Group_0_1__1__Impl
	rule__ParameterDeclaration__Group_0_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParameterDeclarationAccess().getSizeAssignment_0_1_1()); }
	(rule__ParameterDeclaration__SizeAssignment_0_1_1)
	{ after(grammarAccess.getParameterDeclarationAccess().getSizeAssignment_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group_0_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ParameterDeclaration__Group_0_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__Group_0_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getParameterDeclarationAccess().getRightSquareBracketKeyword_0_1_2()); }
	']'
	{ after(grammarAccess.getParameterDeclarationAccess().getRightSquareBracketKeyword_0_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__VariablesDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group__0__Impl
	rule__VariablesDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getVariablesAssignment_0()); }
	(rule__VariablesDeclaration__VariablesAssignment_0)
	{ after(grammarAccess.getVariablesDeclarationAccess().getVariablesAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group__1__Impl
	rule__VariablesDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getGroup_1()); }
	(rule__VariablesDeclaration__Group_1__0)*
	{ after(grammarAccess.getVariablesDeclarationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group__2__Impl
	rule__VariablesDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getColonKeyword_2()); }
	':'
	{ after(grammarAccess.getVariablesDeclarationAccess().getColonKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group__3__Impl
	rule__VariablesDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getTypeAssignment_3()); }
	(rule__VariablesDeclaration__TypeAssignment_3)
	{ after(grammarAccess.getVariablesDeclarationAccess().getTypeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getGroup_4()); }
	(rule__VariablesDeclaration__Group_4__0)?
	{ after(grammarAccess.getVariablesDeclarationAccess().getGroup_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__VariablesDeclaration__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group_1__0__Impl
	rule__VariablesDeclaration__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getCommaKeyword_1_0()); }
	','
	{ after(grammarAccess.getVariablesDeclarationAccess().getCommaKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getVariablesAssignment_1_1()); }
	(rule__VariablesDeclaration__VariablesAssignment_1_1)
	{ after(grammarAccess.getVariablesDeclarationAccess().getVariablesAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__VariablesDeclaration__Group_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group_4__0__Impl
	rule__VariablesDeclaration__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getColonEqualsSignKeyword_4_0()); }
	':='
	{ after(grammarAccess.getVariablesDeclarationAccess().getColonEqualsSignKeyword_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariablesDeclaration__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__Group_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariablesDeclarationAccess().getValueAssignment_4_1()); }
	(rule__VariablesDeclaration__ValueAssignment_4_1)
	{ after(grammarAccess.getVariablesDeclarationAccess().getValueAssignment_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PriorityDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PriorityDeclaration__Group__0__Impl
	rule__PriorityDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPriorityDeclarationAccess().getGroupsAssignment_0()); }
	(rule__PriorityDeclaration__GroupsAssignment_0)
	{ after(grammarAccess.getPriorityDeclarationAccess().getGroupsAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PriorityDeclaration__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	(
		{ before(grammarAccess.getPriorityDeclarationAccess().getGroup_1()); }
		(rule__PriorityDeclaration__Group_1__0)
		{ after(grammarAccess.getPriorityDeclarationAccess().getGroup_1()); }
	)
	(
		{ before(grammarAccess.getPriorityDeclarationAccess().getGroup_1()); }
		(rule__PriorityDeclaration__Group_1__0)*
		{ after(grammarAccess.getPriorityDeclarationAccess().getGroup_1()); }
	)
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PriorityDeclaration__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PriorityDeclaration__Group_1__0__Impl
	rule__PriorityDeclaration__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityDeclaration__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPriorityDeclarationAccess().getGreaterThanSignKeyword_1_0()); }
	'>'
	{ after(grammarAccess.getPriorityDeclarationAccess().getGreaterThanSignKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityDeclaration__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PriorityDeclaration__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityDeclaration__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPriorityDeclarationAccess().getGroupsAssignment_1_1()); }
	(rule__PriorityDeclaration__GroupsAssignment_1_1)
	{ after(grammarAccess.getPriorityDeclarationAccess().getGroupsAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PriorityGroup__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PriorityGroup__Group__0__Impl
	rule__PriorityGroup__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityGroup__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPriorityGroupAccess().getPortsAssignment_0()); }
	(rule__PriorityGroup__PortsAssignment_0)
	{ after(grammarAccess.getPriorityGroupAccess().getPortsAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityGroup__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PriorityGroup__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityGroup__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPriorityGroupAccess().getGroup_1()); }
	(rule__PriorityGroup__Group_1__0)*
	{ after(grammarAccess.getPriorityGroupAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PriorityGroup__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PriorityGroup__Group_1__0__Impl
	rule__PriorityGroup__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityGroup__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPriorityGroupAccess().getVerticalLineKeyword_1_0()); }
	'|'
	{ after(grammarAccess.getPriorityGroupAccess().getVerticalLineKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityGroup__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PriorityGroup__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityGroup__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPriorityGroupAccess().getPortsAssignment_1_1()); }
	(rule__PriorityGroup__PortsAssignment_1_1)
	{ after(grammarAccess.getPriorityGroupAccess().getPortsAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnlessStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnlessStatement__Group__0__Impl
	rule__UnlessStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnlessStatementAccess().getStatementChoiceParserRuleCall_0()); }
	ruleStatementChoice
	{ after(grammarAccess.getUnlessStatementAccess().getStatementChoiceParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnlessStatement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnlessStatementAccess().getGroup_1()); }
	(rule__UnlessStatement__Group_1__0)*
	{ after(grammarAccess.getUnlessStatementAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnlessStatement__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnlessStatement__Group_1__0__Impl
	rule__UnlessStatement__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnlessStatementAccess().getUnlessStatementFollowersAction_1_0()); }
	()
	{ after(grammarAccess.getUnlessStatementAccess().getUnlessStatementFollowersAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnlessStatement__Group_1__1__Impl
	rule__UnlessStatement__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnlessStatementAccess().getUnlessKeyword_1_1()); }
	'unless'
	{ after(grammarAccess.getUnlessStatementAccess().getUnlessKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnlessStatement__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnlessStatementAccess().getFollowersAssignment_1_2()); }
	(rule__UnlessStatement__FollowersAssignment_1_2)
	{ after(grammarAccess.getUnlessStatementAccess().getFollowersAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__StatementChoice__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementChoice__Group__0__Impl
	rule__StatementChoice__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementChoiceAccess().getStatementSequenceParserRuleCall_0()); }
	ruleStatementSequence
	{ after(grammarAccess.getStatementChoiceAccess().getStatementSequenceParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementChoice__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementChoiceAccess().getGroup_1()); }
	(rule__StatementChoice__Group_1__0)*
	{ after(grammarAccess.getStatementChoiceAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__StatementChoice__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementChoice__Group_1__0__Impl
	rule__StatementChoice__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementChoiceAccess().getStatementChoiceChoicesAction_1_0()); }
	()
	{ after(grammarAccess.getStatementChoiceAccess().getStatementChoiceChoicesAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementChoice__Group_1__1__Impl
	rule__StatementChoice__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementChoiceAccess().getLeftSquareBracketRightSquareBracketKeyword_1_1()); }
	'[]'
	{ after(grammarAccess.getStatementChoiceAccess().getLeftSquareBracketRightSquareBracketKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementChoice__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementChoiceAccess().getChoicesAssignment_1_2()); }
	(rule__StatementChoice__ChoicesAssignment_1_2)
	{ after(grammarAccess.getStatementChoiceAccess().getChoicesAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__StatementSequence__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementSequence__Group__0__Impl
	rule__StatementSequence__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementSequenceAccess().getStatementParserRuleCall_0()); }
	ruleStatement
	{ after(grammarAccess.getStatementSequenceAccess().getStatementParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementSequence__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementSequenceAccess().getGroup_1()); }
	(rule__StatementSequence__Group_1__0)*
	{ after(grammarAccess.getStatementSequenceAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__StatementSequence__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementSequence__Group_1__0__Impl
	rule__StatementSequence__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementSequenceAccess().getStatementSequenceStatementsAction_1_0()); }
	()
	{ after(grammarAccess.getStatementSequenceAccess().getStatementSequenceStatementsAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementSequence__Group_1__1__Impl
	rule__StatementSequence__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementSequenceAccess().getSemicolonKeyword_1_1()); }
	';'
	{ after(grammarAccess.getStatementSequenceAccess().getSemicolonKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StatementSequence__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStatementSequenceAccess().getStatementsAssignment_1_2()); }
	(rule__StatementSequence__StatementsAssignment_1_2)
	{ after(grammarAccess.getStatementSequenceAccess().getStatementsAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BlockStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BlockStatement__Group__0__Impl
	rule__BlockStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BlockStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBlockStatementAccess().getBeginKeyword_0()); }
	'begin'
	{ after(grammarAccess.getBlockStatementAccess().getBeginKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BlockStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BlockStatement__Group__1__Impl
	rule__BlockStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__BlockStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBlockStatementAccess().getBodyAssignment_1()); }
	(rule__BlockStatement__BodyAssignment_1)
	{ after(grammarAccess.getBlockStatementAccess().getBodyAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BlockStatement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BlockStatement__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BlockStatement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBlockStatementAccess().getEndKeyword_2()); }
	'end'
	{ after(grammarAccess.getBlockStatementAccess().getEndKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ReturnStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ReturnStatement__Group__0__Impl
	rule__ReturnStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ReturnStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); }
	'return'
	{ after(grammarAccess.getReturnStatementAccess().getReturnKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ReturnStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ReturnStatement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ReturnStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); }
	(rule__ReturnStatement__ExpressionAssignment_1)
	{ after(grammarAccess.getReturnStatementAccess().getExpressionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__NullStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NullStatement__Group__0__Impl
	rule__NullStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__NullStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNullStatementAccess().getNullStatementAction_0()); }
	()
	{ after(grammarAccess.getNullStatementAccess().getNullStatementAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__NullStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NullStatement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__NullStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNullStatementAccess().getNullKeyword_1()); }
	'null'
	{ after(grammarAccess.getNullStatementAccess().getNullKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TaggedStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TaggedStatement__Group__0__Impl
	rule__TaggedStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TaggedStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTaggedStatementAccess().getNumberSignKeyword_0()); }
	'#'
	{ after(grammarAccess.getTaggedStatementAccess().getNumberSignKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TaggedStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TaggedStatement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TaggedStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTaggedStatementAccess().getNameAssignment_1()); }
	(rule__TaggedStatement__NameAssignment_1)
	{ after(grammarAccess.getTaggedStatementAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group__0__Impl
	rule__PatternStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getPatternParserRuleCall_0()); }
	rulePattern
	{ after(grammarAccess.getPatternStatementAccess().getPatternParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getAlternatives_1()); }
	(rule__PatternStatement__Alternatives_1)?
	{ after(grammarAccess.getPatternStatementAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0__0__Impl
	rule__PatternStatement__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_0_0()); }
	','
	{ after(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0__1__Impl
	rule__PatternStatement__Group_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getAssignStatementPatternsAction_1_0_1()); }
	()
	{ after(grammarAccess.getPatternStatementAccess().getAssignStatementPatternsAction_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0__2__Impl
	rule__PatternStatement__Group_1_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_0_2()); }
	(rule__PatternStatement__PatternsAssignment_1_0_2)
	{ after(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0__3__Impl
	rule__PatternStatement__Group_1_0__4
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_0_3()); }
	(rule__PatternStatement__Group_1_0_3__0)*
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0__4__Impl
	rule__PatternStatement__Group_1_0__5
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getColonEqualsSignKeyword_1_0_4()); }
	':='
	{ after(grammarAccess.getPatternStatementAccess().getColonEqualsSignKeyword_1_0_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0__5__Impl
	rule__PatternStatement__Group_1_0__6
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_0_5()); }
	(rule__PatternStatement__ValuesAssignment_1_0_5)
	{ after(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_0_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0__6__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_0_6()); }
	(rule__PatternStatement__Group_1_0_6__0)*
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_0_6()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_0_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0_3__0__Impl
	rule__PatternStatement__Group_1_0_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_0_3_0()); }
	','
	{ after(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_0_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_0_3_1()); }
	(rule__PatternStatement__PatternsAssignment_1_0_3_1)
	{ after(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_0_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_0_6__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0_6__0__Impl
	rule__PatternStatement__Group_1_0_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0_6__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_0_6_0()); }
	','
	{ after(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_0_6_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0_6__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_0_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_0_6__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_0_6_1()); }
	(rule__PatternStatement__ValuesAssignment_1_0_6_1)
	{ after(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_0_6_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_1__0__Impl
	rule__PatternStatement__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getColonEqualsSignKeyword_1_1_0()); }
	':='
	{ after(grammarAccess.getPatternStatementAccess().getColonEqualsSignKeyword_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_1__1__Impl
	rule__PatternStatement__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getAssignStatementPatternsAction_1_1_1()); }
	()
	{ after(grammarAccess.getPatternStatementAccess().getAssignStatementPatternsAction_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_1_2()); }
	(rule__PatternStatement__Group_1_1_2__0)
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_1_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_1_2__0__Impl
	rule__PatternStatement__Group_1_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_1_2_0()); }
	(rule__PatternStatement__ValuesAssignment_1_1_2_0)
	{ after(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_1_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_1_2_1()); }
	(rule__PatternStatement__Group_1_1_2_1__0)*
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_1_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_1_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_1_2_1__0__Impl
	rule__PatternStatement__Group_1_1_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_1_2_1_0()); }
	','
	{ after(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_1_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_1_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_1_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_1_2_1_1()); }
	(rule__PatternStatement__ValuesAssignment_1_1_2_1_1)
	{ after(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_1_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2__0__Impl
	rule__PatternStatement__Group_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_2_0()); }
	','
	{ after(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2__1__Impl
	rule__PatternStatement__Group_1_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getAssignAnyStatementPatternsAction_1_2_1()); }
	()
	{ after(grammarAccess.getPatternStatementAccess().getAssignAnyStatementPatternsAction_1_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2__2__Impl
	rule__PatternStatement__Group_1_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_2_2()); }
	(rule__PatternStatement__PatternsAssignment_1_2_2)
	{ after(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2__3__Impl
	rule__PatternStatement__Group_1_2__4
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_2_3()); }
	(rule__PatternStatement__Group_1_2_3__0)*
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2__4__Impl
	rule__PatternStatement__Group_1_2__5
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getColonEqualsSignKeyword_1_2_4()); }
	':='
	{ after(grammarAccess.getPatternStatementAccess().getColonEqualsSignKeyword_1_2_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2__5__Impl
	rule__PatternStatement__Group_1_2__6
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getAnyKeyword_1_2_5()); }
	'any'
	{ after(grammarAccess.getPatternStatementAccess().getAnyKeyword_1_2_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2__6__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_2_6()); }
	(rule__PatternStatement__Group_1_2_6__0)?
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_2_6()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_2_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2_3__0__Impl
	rule__PatternStatement__Group_1_2_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_2_3_0()); }
	','
	{ after(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_2_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_2_3_1()); }
	(rule__PatternStatement__PatternsAssignment_1_2_3_1)
	{ after(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_2_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_2_6__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2_6__0__Impl
	rule__PatternStatement__Group_1_2_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2_6__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getWhereKeyword_1_2_6_0()); }
	'where'
	{ after(grammarAccess.getPatternStatementAccess().getWhereKeyword_1_2_6_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2_6__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_2_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_2_6__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getExpAssignment_1_2_6_1()); }
	(rule__PatternStatement__ExpAssignment_1_2_6_1)
	{ after(grammarAccess.getPatternStatementAccess().getExpAssignment_1_2_6_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_3__0__Impl
	rule__PatternStatement__Group_1_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getColonEqualsSignKeyword_1_3_0()); }
	':='
	{ after(grammarAccess.getPatternStatementAccess().getColonEqualsSignKeyword_1_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_3__1__Impl
	rule__PatternStatement__Group_1_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getAssignAnyStatementPatternsAction_1_3_1()); }
	()
	{ after(grammarAccess.getPatternStatementAccess().getAssignAnyStatementPatternsAction_1_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_3__2__Impl
	rule__PatternStatement__Group_1_3__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getAnyKeyword_1_3_2()); }
	'any'
	{ after(grammarAccess.getPatternStatementAccess().getAnyKeyword_1_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_3__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_3_3()); }
	(rule__PatternStatement__Group_1_3_3__0)?
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_3_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_3_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_3_3__0__Impl
	rule__PatternStatement__Group_1_3_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getWhereKeyword_1_3_3_0()); }
	'where'
	{ after(grammarAccess.getPatternStatementAccess().getWhereKeyword_1_3_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_3_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_3_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getExpAssignment_1_3_3_1()); }
	(rule__PatternStatement__ExpAssignment_1_3_3_1)
	{ after(grammarAccess.getPatternStatementAccess().getExpAssignment_1_3_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_4__0__Impl
	rule__PatternStatement__Group_1_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getExclamationMarkKeyword_1_4_0()); }
	'!'
	{ after(grammarAccess.getPatternStatementAccess().getExclamationMarkKeyword_1_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_4__1__Impl
	rule__PatternStatement__Group_1_4__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getSendStatementPortAction_1_4_1()); }
	()
	{ after(grammarAccess.getPatternStatementAccess().getSendStatementPortAction_1_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_4__2__Impl
	rule__PatternStatement__Group_1_4__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_4_2()); }
	(rule__PatternStatement__ValuesAssignment_1_4_2)
	{ after(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_4_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_4__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_4_3()); }
	(rule__PatternStatement__Group_1_4_3__0)*
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_4_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_4_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_4_3__0__Impl
	rule__PatternStatement__Group_1_4_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_4_3_0()); }
	','
	{ after(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_4_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_4_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_4_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_4_3_1()); }
	(rule__PatternStatement__ValuesAssignment_1_4_3_1)
	{ after(grammarAccess.getPatternStatementAccess().getValuesAssignment_1_4_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_5__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5__0__Impl
	rule__PatternStatement__Group_1_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getQuestionMarkKeyword_1_5_0()); }
	'?'
	{ after(grammarAccess.getPatternStatementAccess().getQuestionMarkKeyword_1_5_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5__1__Impl
	rule__PatternStatement__Group_1_5__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getReceiveStatementPortAction_1_5_1()); }
	()
	{ after(grammarAccess.getPatternStatementAccess().getReceiveStatementPortAction_1_5_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5__2__Impl
	rule__PatternStatement__Group_1_5__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_5_2()); }
	(rule__PatternStatement__PatternsAssignment_1_5_2)
	{ after(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_5_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5__3__Impl
	rule__PatternStatement__Group_1_5__4
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_5_3()); }
	(rule__PatternStatement__Group_1_5_3__0)*
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_5_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getGroup_1_5_4()); }
	(rule__PatternStatement__Group_1_5_4__0)?
	{ after(grammarAccess.getPatternStatementAccess().getGroup_1_5_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_5_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5_3__0__Impl
	rule__PatternStatement__Group_1_5_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_5_3_0()); }
	','
	{ after(grammarAccess.getPatternStatementAccess().getCommaKeyword_1_5_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_5_3_1()); }
	(rule__PatternStatement__PatternsAssignment_1_5_3_1)
	{ after(grammarAccess.getPatternStatementAccess().getPatternsAssignment_1_5_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PatternStatement__Group_1_5_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5_4__0__Impl
	rule__PatternStatement__Group_1_5_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getWhereKeyword_1_5_4_0()); }
	'where'
	{ after(grammarAccess.getPatternStatementAccess().getWhereKeyword_1_5_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PatternStatement__Group_1_5_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__Group_1_5_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternStatementAccess().getExpAssignment_1_5_4_1()); }
	(rule__PatternStatement__ExpAssignment_1_5_4_1)
	{ after(grammarAccess.getPatternStatementAccess().getExpAssignment_1_5_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Pattern__Group_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Pattern__Group_3__0__Impl
	rule__Pattern__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Pattern__Group_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternAccess().getLeftParenthesisKeyword_3_0()); }
	'('
	{ after(grammarAccess.getPatternAccess().getLeftParenthesisKeyword_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Pattern__Group_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Pattern__Group_3__1__Impl
	rule__Pattern__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Pattern__Group_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternAccess().getPatternParserRuleCall_3_1()); }
	rulePattern
	{ after(grammarAccess.getPatternAccess().getPatternParserRuleCall_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Pattern__Group_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Pattern__Group_3__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Pattern__Group_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPatternAccess().getRightParenthesisKeyword_3_2()); }
	')'
	{ after(grammarAccess.getPatternAccess().getRightParenthesisKeyword_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AnyPattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AnyPattern__Group__0__Impl
	rule__AnyPattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AnyPattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAnyPatternAccess().getAnyPatternAction_0()); }
	()
	{ after(grammarAccess.getAnyPatternAccess().getAnyPatternAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AnyPattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AnyPattern__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AnyPattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAnyPatternAccess().getAnyKeyword_1()); }
	'any'
	{ after(grammarAccess.getAnyPatternAccess().getAnyKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IntegerPattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IntegerPattern__Group__0__Impl
	rule__IntegerPattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerPattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIntegerPatternAccess().getAlternatives_0()); }
	(rule__IntegerPattern__Alternatives_0)
	{ after(grammarAccess.getIntegerPatternAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerPattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IntegerPattern__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerPattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIntegerPatternAccess().getValueAssignment_1()); }
	(rule__IntegerPattern__ValueAssignment_1)
	{ after(grammarAccess.getIntegerPatternAccess().getValueAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierPattern__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0__0__Impl
	rule__IdentifierPattern__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getConstructorPatternAction_0_0()); }
	()
	{ after(grammarAccess.getIdentifierPatternAccess().getConstructorPatternAction_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0__1__Impl
	rule__IdentifierPattern__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getDeclarationAssignment_0_1()); }
	(rule__IdentifierPattern__DeclarationAssignment_0_1)
	{ after(grammarAccess.getIdentifierPatternAccess().getDeclarationAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0__2__Impl
	rule__IdentifierPattern__Group_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getLeftParenthesisKeyword_0_2()); }
	'('
	{ after(grammarAccess.getIdentifierPatternAccess().getLeftParenthesisKeyword_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0__3__Impl
	rule__IdentifierPattern__Group_0__4
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getGroup_0_3()); }
	(rule__IdentifierPattern__Group_0_3__0)?
	{ after(grammarAccess.getIdentifierPatternAccess().getGroup_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getRightParenthesisKeyword_0_4()); }
	')'
	{ after(grammarAccess.getIdentifierPatternAccess().getRightParenthesisKeyword_0_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierPattern__Group_0_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0_3__0__Impl
	rule__IdentifierPattern__Group_0_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getParametersAssignment_0_3_0()); }
	(rule__IdentifierPattern__ParametersAssignment_0_3_0)
	{ after(grammarAccess.getIdentifierPatternAccess().getParametersAssignment_0_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getGroup_0_3_1()); }
	(rule__IdentifierPattern__Group_0_3_1__0)*
	{ after(grammarAccess.getIdentifierPatternAccess().getGroup_0_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierPattern__Group_0_3_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0_3_1__0__Impl
	rule__IdentifierPattern__Group_0_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0_3_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getCommaKeyword_0_3_1_0()); }
	','
	{ after(grammarAccess.getIdentifierPatternAccess().getCommaKeyword_0_3_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0_3_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_0_3_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_0_3_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getParametersAssignment_0_3_1_1()); }
	(rule__IdentifierPattern__ParametersAssignment_0_3_1_1)
	{ after(grammarAccess.getIdentifierPatternAccess().getParametersAssignment_0_3_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierPattern__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1__0__Impl
	rule__IdentifierPattern__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getDeclarationAssignment_1_0()); }
	(rule__IdentifierPattern__DeclarationAssignment_1_0)
	{ after(grammarAccess.getIdentifierPatternAccess().getDeclarationAssignment_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getAlternatives_1_1()); }
	(rule__IdentifierPattern__Alternatives_1_1)*
	{ after(grammarAccess.getIdentifierPatternAccess().getAlternatives_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierPattern__Group_1_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1_1_0__0__Impl
	rule__IdentifierPattern__Group_1_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getLeftSquareBracketKeyword_1_1_0_0()); }
	'['
	{ after(grammarAccess.getIdentifierPatternAccess().getLeftSquareBracketKeyword_1_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1_1_0__1__Impl
	rule__IdentifierPattern__Group_1_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getArrayAccessPatternSourceAction_1_1_0_1()); }
	()
	{ after(grammarAccess.getIdentifierPatternAccess().getArrayAccessPatternSourceAction_1_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1_1_0__2__Impl
	rule__IdentifierPattern__Group_1_1_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getIndexAssignment_1_1_0_2()); }
	(rule__IdentifierPattern__IndexAssignment_1_1_0_2)
	{ after(grammarAccess.getIdentifierPatternAccess().getIndexAssignment_1_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1_1_0__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getRightSquareBracketKeyword_1_1_0_3()); }
	']'
	{ after(grammarAccess.getIdentifierPatternAccess().getRightSquareBracketKeyword_1_1_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierPattern__Group_1_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1_1_1__0__Impl
	rule__IdentifierPattern__Group_1_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getFullStopKeyword_1_1_1_0()); }
	'.'
	{ after(grammarAccess.getIdentifierPatternAccess().getFullStopKeyword_1_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1_1_1__1__Impl
	rule__IdentifierPattern__Group_1_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getRecordAccessPatternSourceAction_1_1_1_1()); }
	()
	{ after(grammarAccess.getIdentifierPatternAccess().getRecordAccessPatternSourceAction_1_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierPattern__Group_1_1_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__Group_1_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierPatternAccess().getFieldAssignment_1_1_1_2()); }
	(rule__IdentifierPattern__FieldAssignment_1_1_1_2)
	{ after(grammarAccess.getIdentifierPatternAccess().getFieldAssignment_1_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ConditionalStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group__0__Impl
	rule__ConditionalStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getIfKeyword_0()); }
	'if'
	{ after(grammarAccess.getConditionalStatementAccess().getIfKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group__1__Impl
	rule__ConditionalStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getConditionAssignment_1()); }
	(rule__ConditionalStatement__ConditionAssignment_1)
	{ after(grammarAccess.getConditionalStatementAccess().getConditionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group__2__Impl
	rule__ConditionalStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getThenKeyword_2()); }
	'then'
	{ after(grammarAccess.getConditionalStatementAccess().getThenKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group__3__Impl
	rule__ConditionalStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getThenAssignment_3()); }
	(rule__ConditionalStatement__ThenAssignment_3)
	{ after(grammarAccess.getConditionalStatementAccess().getThenAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group__4__Impl
	rule__ConditionalStatement__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getElseifAssignment_4()); }
	(rule__ConditionalStatement__ElseifAssignment_4)*
	{ after(grammarAccess.getConditionalStatementAccess().getElseifAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group__5__Impl
	rule__ConditionalStatement__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getGroup_5()); }
	(rule__ConditionalStatement__Group_5__0)?
	{ after(grammarAccess.getConditionalStatementAccess().getGroup_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group__6__Impl
	rule__ConditionalStatement__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__6__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getEndKeyword_6()); }
	'end'
	{ after(grammarAccess.getConditionalStatementAccess().getEndKeyword_6()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__7
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group__7__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group__7__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getIfKeyword_7()); }
	('if')?
	{ after(grammarAccess.getConditionalStatementAccess().getIfKeyword_7()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ConditionalStatement__Group_5__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group_5__0__Impl
	rule__ConditionalStatement__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group_5__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getElseKeyword_5_0()); }
	'else'
	{ after(grammarAccess.getConditionalStatementAccess().getElseKeyword_5_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group_5__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalStatement__Group_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__Group_5__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalStatementAccess().getElseAssignment_5_1()); }
	(rule__ConditionalStatement__ElseAssignment_5_1)
	{ after(grammarAccess.getConditionalStatementAccess().getElseAssignment_5_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExtendedConditionalStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExtendedConditionalStatement__Group__0__Impl
	rule__ExtendedConditionalStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExtendedConditionalStatementAccess().getElsifKeyword_0()); }
	'elsif'
	{ after(grammarAccess.getExtendedConditionalStatementAccess().getElsifKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExtendedConditionalStatement__Group__1__Impl
	rule__ExtendedConditionalStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExtendedConditionalStatementAccess().getConditionAssignment_1()); }
	(rule__ExtendedConditionalStatement__ConditionAssignment_1)
	{ after(grammarAccess.getExtendedConditionalStatementAccess().getConditionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExtendedConditionalStatement__Group__2__Impl
	rule__ExtendedConditionalStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExtendedConditionalStatementAccess().getThenKeyword_2()); }
	'then'
	{ after(grammarAccess.getExtendedConditionalStatementAccess().getThenKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExtendedConditionalStatement__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExtendedConditionalStatementAccess().getThenAssignment_3()); }
	(rule__ExtendedConditionalStatement__ThenAssignment_3)
	{ after(grammarAccess.getExtendedConditionalStatementAccess().getThenAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SelectStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group__0__Impl
	rule__SelectStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getSelectKeyword_0()); }
	'select'
	{ after(grammarAccess.getSelectStatementAccess().getSelectKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group__1__Impl
	rule__SelectStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getBodyAssignment_1()); }
	(rule__SelectStatement__BodyAssignment_1)
	{ after(grammarAccess.getSelectStatementAccess().getBodyAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group__2__Impl
	rule__SelectStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getGroup_2()); }
	(rule__SelectStatement__Group_2__0)?
	{ after(grammarAccess.getSelectStatementAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group__3__Impl
	rule__SelectStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getEndKeyword_3()); }
	'end'
	{ after(grammarAccess.getSelectStatementAccess().getEndKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getSelectKeyword_4()); }
	('select')?
	{ after(grammarAccess.getSelectStatementAccess().getSelectKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SelectStatement__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group_2__0__Impl
	rule__SelectStatement__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getVerticalLineKeyword_2_0()); }
	'|'
	{ after(grammarAccess.getSelectStatementAccess().getVerticalLineKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group_2__1__Impl
	rule__SelectStatement__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getIndexAssignment_2_1()); }
	(rule__SelectStatement__IndexAssignment_2_1)
	{ after(grammarAccess.getSelectStatementAccess().getIndexAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group_2__2__Impl
	rule__SelectStatement__Group_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getInKeyword_2_2()); }
	'in'
	{ after(grammarAccess.getSelectStatementAccess().getInKeyword_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SelectStatement__Group_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__Group_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSelectStatementAccess().getTypeAssignment_2_3()); }
	(rule__SelectStatement__TypeAssignment_2_3)
	{ after(grammarAccess.getSelectStatementAccess().getTypeAssignment_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__WhileStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WhileStatement__Group__0__Impl
	rule__WhileStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); }
	'while'
	{ after(grammarAccess.getWhileStatementAccess().getWhileKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WhileStatement__Group__1__Impl
	rule__WhileStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWhileStatementAccess().getConditionAssignment_1()); }
	(rule__WhileStatement__ConditionAssignment_1)
	{ after(grammarAccess.getWhileStatementAccess().getConditionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WhileStatement__Group__2__Impl
	rule__WhileStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWhileStatementAccess().getDoKeyword_2()); }
	'do'
	{ after(grammarAccess.getWhileStatementAccess().getDoKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WhileStatement__Group__3__Impl
	rule__WhileStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWhileStatementAccess().getBodyAssignment_3()); }
	(rule__WhileStatement__BodyAssignment_3)
	{ after(grammarAccess.getWhileStatementAccess().getBodyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WhileStatement__Group__4__Impl
	rule__WhileStatement__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWhileStatementAccess().getEndKeyword_4()); }
	'end'
	{ after(grammarAccess.getWhileStatementAccess().getEndKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WhileStatement__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWhileStatementAccess().getWhileKeyword_5()); }
	('while')?
	{ after(grammarAccess.getWhileStatementAccess().getWhileKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ForeachStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ForeachStatement__Group__0__Impl
	rule__ForeachStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getForeachStatementAccess().getForeachKeyword_0()); }
	'foreach'
	{ after(grammarAccess.getForeachStatementAccess().getForeachKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ForeachStatement__Group__1__Impl
	rule__ForeachStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getForeachStatementAccess().getVariableAssignment_1()); }
	(rule__ForeachStatement__VariableAssignment_1)
	{ after(grammarAccess.getForeachStatementAccess().getVariableAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ForeachStatement__Group__2__Impl
	rule__ForeachStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getForeachStatementAccess().getDoKeyword_2()); }
	'do'
	{ after(grammarAccess.getForeachStatementAccess().getDoKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ForeachStatement__Group__3__Impl
	rule__ForeachStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getForeachStatementAccess().getBodyAssignment_3()); }
	(rule__ForeachStatement__BodyAssignment_3)
	{ after(grammarAccess.getForeachStatementAccess().getBodyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ForeachStatement__Group__4__Impl
	rule__ForeachStatement__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getForeachStatementAccess().getEndKeyword_4()); }
	'end'
	{ after(grammarAccess.getForeachStatementAccess().getEndKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ForeachStatement__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getForeachStatementAccess().getForeachKeyword_5()); }
	('foreach')?
	{ after(grammarAccess.getForeachStatementAccess().getForeachKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ToStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ToStatement__Group__0__Impl
	rule__ToStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ToStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getToStatementAccess().getToKeyword_0()); }
	'to'
	{ after(grammarAccess.getToStatementAccess().getToKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ToStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ToStatement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ToStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getToStatementAccess().getStateAssignment_1()); }
	(rule__ToStatement__StateAssignment_1)
	{ after(grammarAccess.getToStatementAccess().getStateAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__CaseStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__0__Impl
	rule__CaseStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getCaseKeyword_0()); }
	'case'
	{ after(grammarAccess.getCaseStatementAccess().getCaseKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__1__Impl
	rule__CaseStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getValueAssignment_1()); }
	(rule__CaseStatement__ValueAssignment_1)
	{ after(grammarAccess.getCaseStatementAccess().getValueAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__2__Impl
	rule__CaseStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getOfKeyword_2()); }
	'of'
	{ after(grammarAccess.getCaseStatementAccess().getOfKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__3__Impl
	rule__CaseStatement__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getPatternAssignment_3()); }
	(rule__CaseStatement__PatternAssignment_3)
	{ after(grammarAccess.getCaseStatementAccess().getPatternAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__4__Impl
	rule__CaseStatement__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getHyphenMinusGreaterThanSignKeyword_4()); }
	'->'
	{ after(grammarAccess.getCaseStatementAccess().getHyphenMinusGreaterThanSignKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__5__Impl
	rule__CaseStatement__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getBodyAssignment_5()); }
	(rule__CaseStatement__BodyAssignment_5)
	{ after(grammarAccess.getCaseStatementAccess().getBodyAssignment_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__6__Impl
	rule__CaseStatement__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__6__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getGroup_6()); }
	(rule__CaseStatement__Group_6__0)*
	{ after(grammarAccess.getCaseStatementAccess().getGroup_6()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__7
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__7__Impl
	rule__CaseStatement__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__7__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getEndKeyword_7()); }
	'end'
	{ after(grammarAccess.getCaseStatementAccess().getEndKeyword_7()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__8
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group__8__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group__8__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getCaseKeyword_8()); }
	('case')?
	{ after(grammarAccess.getCaseStatementAccess().getCaseKeyword_8()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__CaseStatement__Group_6__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group_6__0__Impl
	rule__CaseStatement__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group_6__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getVerticalLineKeyword_6_0()); }
	'|'
	{ after(grammarAccess.getCaseStatementAccess().getVerticalLineKeyword_6_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group_6__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group_6__1__Impl
	rule__CaseStatement__Group_6__2
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group_6__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getPatternAssignment_6_1()); }
	(rule__CaseStatement__PatternAssignment_6_1)
	{ after(grammarAccess.getCaseStatementAccess().getPatternAssignment_6_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group_6__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group_6__2__Impl
	rule__CaseStatement__Group_6__3
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group_6__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getHyphenMinusGreaterThanSignKeyword_6_2()); }
	'->'
	{ after(grammarAccess.getCaseStatementAccess().getHyphenMinusGreaterThanSignKeyword_6_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group_6__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CaseStatement__Group_6__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__Group_6__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseStatementAccess().getBodyAssignment_6_3()); }
	(rule__CaseStatement__BodyAssignment_6_3)
	{ after(grammarAccess.getCaseStatementAccess().getBodyAssignment_6_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LoopStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LoopStatement__Group__0__Impl
	rule__LoopStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LoopStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLoopStatementAccess().getLoopStatementAction_0()); }
	()
	{ after(grammarAccess.getLoopStatementAccess().getLoopStatementAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LoopStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LoopStatement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LoopStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLoopStatementAccess().getLoopKeyword_1()); }
	'loop'
	{ after(grammarAccess.getLoopStatementAccess().getLoopKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__OnStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__OnStatement__Group__0__Impl
	rule__OnStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__OnStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getOnStatementAccess().getOnKeyword_0()); }
	'on'
	{ after(grammarAccess.getOnStatementAccess().getOnKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__OnStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__OnStatement__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__OnStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getOnStatementAccess().getConditionAssignment_1()); }
	(rule__OnStatement__ConditionAssignment_1)
	{ after(grammarAccess.getOnStatementAccess().getConditionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__WaitStatement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WaitStatement__Group__0__Impl
	rule__WaitStatement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWaitStatementAccess().getWaitKeyword_0()); }
	'wait'
	{ after(grammarAccess.getWaitStatementAccess().getWaitKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WaitStatement__Group__1__Impl
	rule__WaitStatement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWaitStatementAccess().getLeftAssignment_1()); }
	(rule__WaitStatement__LeftAssignment_1)
	{ after(grammarAccess.getWaitStatementAccess().getLeftAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WaitStatement__Group__2__Impl
	rule__WaitStatement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWaitStatementAccess().getCommaKeyword_2()); }
	','
	{ after(grammarAccess.getWaitStatementAccess().getCommaKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__WaitStatement__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getWaitStatementAccess().getRightAssignment_3()); }
	(rule__WaitStatement__RightAssignment_3)
	{ after(grammarAccess.getWaitStatementAccess().getRightAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Composition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group__0__Impl
	rule__Composition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getParKeyword_0()); }
	'par'
	{ after(grammarAccess.getCompositionAccess().getParKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group__1__Impl
	rule__Composition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getGroup_1()); }
	(rule__Composition__Group_1__0)?
	{ after(grammarAccess.getCompositionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group__2__Impl
	rule__Composition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getBlocksAssignment_2()); }
	(rule__Composition__BlocksAssignment_2)
	{ after(grammarAccess.getCompositionAccess().getBlocksAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group__3__Impl
	rule__Composition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getGroup_3()); }
	(rule__Composition__Group_3__0)*
	{ after(grammarAccess.getCompositionAccess().getGroup_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group__4__Impl
	rule__Composition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getEndKeyword_4()); }
	'end'
	{ after(grammarAccess.getCompositionAccess().getEndKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getParKeyword_5()); }
	('par')?
	{ after(grammarAccess.getCompositionAccess().getParKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Composition__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group_1__0__Impl
	rule__Composition__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getGlobalAssignment_1_0()); }
	(rule__Composition__GlobalAssignment_1_0)
	{ after(grammarAccess.getCompositionAccess().getGlobalAssignment_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getInKeyword_1_1()); }
	'in'
	{ after(grammarAccess.getCompositionAccess().getInKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Composition__Group_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group_3__0__Impl
	rule__Composition__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getVerticalLineVerticalLineKeyword_3_0()); }
	'||'
	{ after(grammarAccess.getCompositionAccess().getVerticalLineVerticalLineKeyword_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Composition__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__Group_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositionAccess().getBlocksAssignment_3_1()); }
	(rule__Composition__BlocksAssignment_3_1)
	{ after(grammarAccess.getCompositionAccess().getBlocksAssignment_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__CompositeBlock__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CompositeBlock__Group__0__Impl
	rule__CompositeBlock__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositeBlockAccess().getAlternatives_0()); }
	(rule__CompositeBlock__Alternatives_0)?
	{ after(grammarAccess.getCompositeBlockAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CompositeBlock__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositeBlockAccess().getCompositionAssignment_1()); }
	(rule__CompositeBlock__CompositionAssignment_1)
	{ after(grammarAccess.getCompositeBlockAccess().getCompositionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__CompositeBlock__Group_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CompositeBlock__Group_0_0__0__Impl
	rule__CompositeBlock__Group_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__Group_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositeBlockAccess().getLocalAssignment_0_0_0()); }
	(rule__CompositeBlock__LocalAssignment_0_0_0)
	{ after(grammarAccess.getCompositeBlockAccess().getLocalAssignment_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__Group_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CompositeBlock__Group_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__Group_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCompositeBlockAccess().getHyphenMinusGreaterThanSignKeyword_0_0_1()); }
	'->'
	{ after(grammarAccess.getCompositeBlockAccess().getHyphenMinusGreaterThanSignKeyword_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__InstanceDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InstanceDeclaration__Group__0__Impl
	rule__InstanceDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInstanceDeclarationAccess().getAlternatives_0()); }
	(rule__InstanceDeclaration__Alternatives_0)?
	{ after(grammarAccess.getInstanceDeclarationAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InstanceDeclaration__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInstanceDeclarationAccess().getInstanceAssignment_1()); }
	(rule__InstanceDeclaration__InstanceAssignment_1)
	{ after(grammarAccess.getInstanceDeclarationAccess().getInstanceAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__InstanceDeclaration__Group_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InstanceDeclaration__Group_0_0__0__Impl
	rule__InstanceDeclaration__Group_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__Group_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInstanceDeclarationAccess().getLocalAssignment_0_0_0()); }
	(rule__InstanceDeclaration__LocalAssignment_0_0_0)
	{ after(grammarAccess.getInstanceDeclarationAccess().getLocalAssignment_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__Group_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InstanceDeclaration__Group_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__Group_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInstanceDeclarationAccess().getHyphenMinusGreaterThanSignKeyword_0_0_1()); }
	'->'
	{ after(grammarAccess.getInstanceDeclarationAccess().getHyphenMinusGreaterThanSignKeyword_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PortSet__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortSet__Group_1__0__Impl
	rule__PortSet__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortSetAccess().getPortsAssignment_1_0()); }
	(rule__PortSet__PortsAssignment_1_0)
	{ after(grammarAccess.getPortSetAccess().getPortsAssignment_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortSet__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortSetAccess().getGroup_1_1()); }
	(rule__PortSet__Group_1_1__0)*
	{ after(grammarAccess.getPortSetAccess().getGroup_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PortSet__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortSet__Group_1_1__0__Impl
	rule__PortSet__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortSetAccess().getCommaKeyword_1_1_0()); }
	','
	{ after(grammarAccess.getPortSetAccess().getCommaKeyword_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PortSet__Group_1_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPortSetAccess().getPortsAssignment_1_1_1()); }
	(rule__PortSet__PortsAssignment_1_1_1)
	{ after(grammarAccess.getPortSetAccess().getPortsAssignment_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentInstance__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group__0__Impl
	rule__ComponentInstance__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getComponentAssignment_0()); }
	(rule__ComponentInstance__ComponentAssignment_0)
	{ after(grammarAccess.getComponentInstanceAccess().getComponentAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group__1__Impl
	rule__ComponentInstance__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getGroup_1()); }
	(rule__ComponentInstance__Group_1__0)?
	{ after(grammarAccess.getComponentInstanceAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getGroup_2()); }
	(rule__ComponentInstance__Group_2__0)?
	{ after(grammarAccess.getComponentInstanceAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentInstance__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_1__0__Impl
	rule__ComponentInstance__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getLeftSquareBracketKeyword_1_0()); }
	'['
	{ after(grammarAccess.getComponentInstanceAccess().getLeftSquareBracketKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_1__1__Impl
	rule__ComponentInstance__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getPortsAssignment_1_1()); }
	(rule__ComponentInstance__PortsAssignment_1_1)
	{ after(grammarAccess.getComponentInstanceAccess().getPortsAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_1__2__Impl
	rule__ComponentInstance__Group_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getGroup_1_2()); }
	(rule__ComponentInstance__Group_1_2__0)*
	{ after(grammarAccess.getComponentInstanceAccess().getGroup_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getRightSquareBracketKeyword_1_3()); }
	']'
	{ after(grammarAccess.getComponentInstanceAccess().getRightSquareBracketKeyword_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentInstance__Group_1_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_1_2__0__Impl
	rule__ComponentInstance__Group_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getCommaKeyword_1_2_0()); }
	','
	{ after(grammarAccess.getComponentInstanceAccess().getCommaKeyword_1_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_1_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getPortsAssignment_1_2_1()); }
	(rule__ComponentInstance__PortsAssignment_1_2_1)
	{ after(grammarAccess.getComponentInstanceAccess().getPortsAssignment_1_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentInstance__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_2__0__Impl
	rule__ComponentInstance__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getLeftParenthesisKeyword_2_0()); }
	'('
	{ after(grammarAccess.getComponentInstanceAccess().getLeftParenthesisKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_2__1__Impl
	rule__ComponentInstance__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getParametersAssignment_2_1()); }
	(rule__ComponentInstance__ParametersAssignment_2_1)
	{ after(grammarAccess.getComponentInstanceAccess().getParametersAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_2__2__Impl
	rule__ComponentInstance__Group_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getGroup_2_2()); }
	(rule__ComponentInstance__Group_2_2__0)*
	{ after(grammarAccess.getComponentInstanceAccess().getGroup_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getRightParenthesisKeyword_2_3()); }
	')'
	{ after(grammarAccess.getComponentInstanceAccess().getRightParenthesisKeyword_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentInstance__Group_2_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_2_2__0__Impl
	rule__ComponentInstance__Group_2_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getCommaKeyword_2_2_0()); }
	','
	{ after(grammarAccess.getComponentInstanceAccess().getCommaKeyword_2_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComponentInstance__Group_2_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__Group_2_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComponentInstanceAccess().getParametersAssignment_2_2_1()); }
	(rule__ComponentInstance__ParametersAssignment_2_2_1)
	{ after(grammarAccess.getComponentInstanceAccess().getParametersAssignment_2_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QuantifiedExpression__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0__0__Impl
	rule__QuantifiedExpression__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getAlternatives_0_0()); }
	(rule__QuantifiedExpression__Alternatives_0_0)
	{ after(grammarAccess.getQuantifiedExpressionAccess().getAlternatives_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0__1__Impl
	rule__QuantifiedExpression__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getIndexAssignment_0_1()); }
	(rule__QuantifiedExpression__IndexAssignment_0_1)
	{ after(grammarAccess.getQuantifiedExpressionAccess().getIndexAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0__2__Impl
	rule__QuantifiedExpression__Group_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getGroup_0_2()); }
	(rule__QuantifiedExpression__Group_0_2__0)?
	{ after(grammarAccess.getQuantifiedExpressionAccess().getGroup_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0__3__Impl
	rule__QuantifiedExpression__Group_0__4
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getFullStopKeyword_0_3()); }
	'.'
	{ after(grammarAccess.getQuantifiedExpressionAccess().getFullStopKeyword_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getChildAssignment_0_4()); }
	(rule__QuantifiedExpression__ChildAssignment_0_4)
	{ after(grammarAccess.getQuantifiedExpressionAccess().getChildAssignment_0_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QuantifiedExpression__Group_0_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0_0_0__0__Impl
	rule__QuantifiedExpression__Group_0_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getAllExpressionAction_0_0_0_0()); }
	()
	{ after(grammarAccess.getQuantifiedExpressionAccess().getAllExpressionAction_0_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getAllKeyword_0_0_0_1()); }
	'all'
	{ after(grammarAccess.getQuantifiedExpressionAccess().getAllKeyword_0_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QuantifiedExpression__Group_0_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0_0_1__0__Impl
	rule__QuantifiedExpression__Group_0_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getExistsExpressionAction_0_0_1_0()); }
	()
	{ after(grammarAccess.getQuantifiedExpressionAccess().getExistsExpressionAction_0_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getExistsKeyword_0_0_1_1()); }
	'exists'
	{ after(grammarAccess.getQuantifiedExpressionAccess().getExistsKeyword_0_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QuantifiedExpression__Group_0_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0_2__0__Impl
	rule__QuantifiedExpression__Group_0_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getInKeyword_0_2_0()); }
	'in'
	{ after(grammarAccess.getQuantifiedExpressionAccess().getInKeyword_0_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedExpression__Group_0_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__Group_0_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedExpressionAccess().getTypeAssignment_0_2_1()); }
	(rule__QuantifiedExpression__TypeAssignment_0_2_1)
	{ after(grammarAccess.getQuantifiedExpressionAccess().getTypeAssignment_0_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Conditional__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conditional__Group__0__Impl
	rule__Conditional__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalAccess().getDisjunctionParserRuleCall_0()); }
	ruleDisjunction
	{ after(grammarAccess.getConditionalAccess().getDisjunctionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conditional__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalAccess().getGroup_1()); }
	(rule__Conditional__Group_1__0)?
	{ after(grammarAccess.getConditionalAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Conditional__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conditional__Group_1__0__Impl
	rule__Conditional__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalAccess().getQuestionMarkKeyword_1_0()); }
	'?'
	{ after(grammarAccess.getConditionalAccess().getQuestionMarkKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conditional__Group_1__1__Impl
	rule__Conditional__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalAccess().getConditionalConditionAction_1_1()); }
	()
	{ after(grammarAccess.getConditionalAccess().getConditionalConditionAction_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conditional__Group_1__2__Impl
	rule__Conditional__Group_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalAccess().getThenAssignment_1_2()); }
	(rule__Conditional__ThenAssignment_1_2)
	{ after(grammarAccess.getConditionalAccess().getThenAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conditional__Group_1__3__Impl
	rule__Conditional__Group_1__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalAccess().getColonKeyword_1_3()); }
	':'
	{ after(grammarAccess.getConditionalAccess().getColonKeyword_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conditional__Group_1__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__Group_1__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalAccess().getElseAssignment_1_4()); }
	(rule__Conditional__ElseAssignment_1_4)
	{ after(grammarAccess.getConditionalAccess().getElseAssignment_1_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Disjunction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Disjunction__Group__0__Impl
	rule__Disjunction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctionAccess().getImplicationParserRuleCall_0()); }
	ruleImplication
	{ after(grammarAccess.getDisjunctionAccess().getImplicationParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Disjunction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctionAccess().getGroup_1()); }
	(rule__Disjunction__Group_1__0)*
	{ after(grammarAccess.getDisjunctionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Disjunction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Disjunction__Group_1__0__Impl
	rule__Disjunction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctionAccess().getDisjunctionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getDisjunctionAccess().getDisjunctionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Disjunction__Group_1__1__Impl
	rule__Disjunction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctionAccess().getOrKeyword_1_1()); }
	'or'
	{ after(grammarAccess.getDisjunctionAccess().getOrKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Disjunction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctionAccess().getRightAssignment_1_2()); }
	(rule__Disjunction__RightAssignment_1_2)
	{ after(grammarAccess.getDisjunctionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Implication__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Implication__Group__0__Impl
	rule__Implication__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationAccess().getConjunctionParserRuleCall_0()); }
	ruleConjunction
	{ after(grammarAccess.getImplicationAccess().getConjunctionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Implication__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationAccess().getGroup_1()); }
	(rule__Implication__Group_1__0)?
	{ after(grammarAccess.getImplicationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Implication__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Implication__Group_1__0__Impl
	rule__Implication__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationAccess().getImplicationLeftAction_1_0()); }
	()
	{ after(grammarAccess.getImplicationAccess().getImplicationLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Implication__Group_1__1__Impl
	rule__Implication__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
	'=>'
	{ after(grammarAccess.getImplicationAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Implication__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getImplicationAccess().getRightAssignment_1_2()); }
	(rule__Implication__RightAssignment_1_2)
	{ after(grammarAccess.getImplicationAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Conjunction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conjunction__Group__0__Impl
	rule__Conjunction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctionAccess().getComparisonParserRuleCall_0()); }
	ruleComparison
	{ after(grammarAccess.getConjunctionAccess().getComparisonParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conjunction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctionAccess().getGroup_1()); }
	(rule__Conjunction__Group_1__0)*
	{ after(grammarAccess.getConjunctionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Conjunction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conjunction__Group_1__0__Impl
	rule__Conjunction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctionAccess().getConjunctionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getConjunctionAccess().getConjunctionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conjunction__Group_1__1__Impl
	rule__Conjunction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctionAccess().getAndKeyword_1_1()); }
	'and'
	{ after(grammarAccess.getConjunctionAccess().getAndKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Conjunction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctionAccess().getRightAssignment_1_2()); }
	(rule__Conjunction__RightAssignment_1_2)
	{ after(grammarAccess.getConjunctionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Comparison__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group__0__Impl
	rule__Comparison__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getAdditionParserRuleCall_0()); }
	ruleAddition
	{ after(grammarAccess.getComparisonAccess().getAdditionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getGroup_1()); }
	(rule__Comparison__Group_1__0)?
	{ after(grammarAccess.getComparisonAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Comparison__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1__0__Impl
	rule__Comparison__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getAlternatives_1_0()); }
	(rule__Comparison__Alternatives_1_0)
	{ after(grammarAccess.getComparisonAccess().getAlternatives_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getRightAssignment_1_1()); }
	(rule__Comparison__RightAssignment_1_1)
	{ after(grammarAccess.getComparisonAccess().getRightAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Comparison__Group_1_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_0__0__Impl
	rule__Comparison__Group_1_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getComparisonEqualLeftAction_1_0_0_0()); }
	()
	{ after(grammarAccess.getComparisonAccess().getComparisonEqualLeftAction_1_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getEqualsSignKeyword_1_0_0_1()); }
	'='
	{ after(grammarAccess.getComparisonAccess().getEqualsSignKeyword_1_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Comparison__Group_1_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_1__0__Impl
	rule__Comparison__Group_1_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getComparisonNotEqualLeftAction_1_0_1_0()); }
	()
	{ after(grammarAccess.getComparisonAccess().getComparisonNotEqualLeftAction_1_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getLessThanSignGreaterThanSignKeyword_1_0_1_1()); }
	'<>'
	{ after(grammarAccess.getComparisonAccess().getLessThanSignGreaterThanSignKeyword_1_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Comparison__Group_1_0_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_2__0__Impl
	rule__Comparison__Group_1_0_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getComparisonLesserLeftAction_1_0_2_0()); }
	()
	{ after(grammarAccess.getComparisonAccess().getComparisonLesserLeftAction_1_0_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getLessThanSignKeyword_1_0_2_1()); }
	'<'
	{ after(grammarAccess.getComparisonAccess().getLessThanSignKeyword_1_0_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Comparison__Group_1_0_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_3__0__Impl
	rule__Comparison__Group_1_0_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getComparisonLesserEqualLeftAction_1_0_3_0()); }
	()
	{ after(grammarAccess.getComparisonAccess().getComparisonLesserEqualLeftAction_1_0_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_3_1()); }
	'<='
	{ after(grammarAccess.getComparisonAccess().getLessThanSignEqualsSignKeyword_1_0_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Comparison__Group_1_0_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_4__0__Impl
	rule__Comparison__Group_1_0_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getComparisonGreaterLeftAction_1_0_4_0()); }
	()
	{ after(grammarAccess.getComparisonAccess().getComparisonGreaterLeftAction_1_0_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getGreaterThanSignKeyword_1_0_4_1()); }
	'>'
	{ after(grammarAccess.getComparisonAccess().getGreaterThanSignKeyword_1_0_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Comparison__Group_1_0_5__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_5__0__Impl
	rule__Comparison__Group_1_0_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_5__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getComparisonGreaterEqualLeftAction_1_0_5_0()); }
	()
	{ after(grammarAccess.getComparisonAccess().getComparisonGreaterEqualLeftAction_1_0_5_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_5__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Comparison__Group_1_0_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__Group_1_0_5__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_5_1()); }
	'>='
	{ after(grammarAccess.getComparisonAccess().getGreaterThanSignEqualsSignKeyword_1_0_5_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Addition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Addition__Group__0__Impl
	rule__Addition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditionAccess().getSubstractionParserRuleCall_0()); }
	ruleSubstraction
	{ after(grammarAccess.getAdditionAccess().getSubstractionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Addition__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditionAccess().getGroup_1()); }
	(rule__Addition__Group_1__0)*
	{ after(grammarAccess.getAdditionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Addition__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Addition__Group_1__0__Impl
	rule__Addition__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditionAccess().getAdditionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getAdditionAccess().getAdditionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Addition__Group_1__1__Impl
	rule__Addition__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditionAccess().getPlusSignKeyword_1_1()); }
	'+'
	{ after(grammarAccess.getAdditionAccess().getPlusSignKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Addition__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditionAccess().getRightAssignment_1_2()); }
	(rule__Addition__RightAssignment_1_2)
	{ after(grammarAccess.getAdditionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Substraction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Substraction__Group__0__Impl
	rule__Substraction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSubstractionAccess().getMultiplicationParserRuleCall_0()); }
	ruleMultiplication
	{ after(grammarAccess.getSubstractionAccess().getMultiplicationParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Substraction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSubstractionAccess().getGroup_1()); }
	(rule__Substraction__Group_1__0)*
	{ after(grammarAccess.getSubstractionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Substraction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Substraction__Group_1__0__Impl
	rule__Substraction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSubstractionAccess().getSubstractionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getSubstractionAccess().getSubstractionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Substraction__Group_1__1__Impl
	rule__Substraction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSubstractionAccess().getHyphenMinusKeyword_1_1()); }
	'-'
	{ after(grammarAccess.getSubstractionAccess().getHyphenMinusKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Substraction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSubstractionAccess().getRightAssignment_1_2()); }
	(rule__Substraction__RightAssignment_1_2)
	{ after(grammarAccess.getSubstractionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Multiplication__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Multiplication__Group__0__Impl
	rule__Multiplication__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicationAccess().getDivisionParserRuleCall_0()); }
	ruleDivision
	{ after(grammarAccess.getMultiplicationAccess().getDivisionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Multiplication__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicationAccess().getGroup_1()); }
	(rule__Multiplication__Group_1__0)*
	{ after(grammarAccess.getMultiplicationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Multiplication__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Multiplication__Group_1__0__Impl
	rule__Multiplication__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicationAccess().getMultiplicationLeftAction_1_0()); }
	()
	{ after(grammarAccess.getMultiplicationAccess().getMultiplicationLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Multiplication__Group_1__1__Impl
	rule__Multiplication__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicationAccess().getAsteriskKeyword_1_1()); }
	'*'
	{ after(grammarAccess.getMultiplicationAccess().getAsteriskKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Multiplication__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicationAccess().getRightAssignment_1_2()); }
	(rule__Multiplication__RightAssignment_1_2)
	{ after(grammarAccess.getMultiplicationAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Division__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Division__Group__0__Impl
	rule__Division__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDivisionAccess().getModuloParserRuleCall_0()); }
	ruleModulo
	{ after(grammarAccess.getDivisionAccess().getModuloParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Division__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDivisionAccess().getGroup_1()); }
	(rule__Division__Group_1__0)*
	{ after(grammarAccess.getDivisionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Division__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Division__Group_1__0__Impl
	rule__Division__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDivisionAccess().getDivisionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getDivisionAccess().getDivisionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Division__Group_1__1__Impl
	rule__Division__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDivisionAccess().getSolidusKeyword_1_1()); }
	'/'
	{ after(grammarAccess.getDivisionAccess().getSolidusKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Division__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDivisionAccess().getRightAssignment_1_2()); }
	(rule__Division__RightAssignment_1_2)
	{ after(grammarAccess.getDivisionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Modulo__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Modulo__Group__0__Impl
	rule__Modulo__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getModuloAccess().getUnaryExpressionParserRuleCall_0()); }
	ruleUnaryExpression
	{ after(grammarAccess.getModuloAccess().getUnaryExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Modulo__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getModuloAccess().getGroup_1()); }
	(rule__Modulo__Group_1__0)*
	{ after(grammarAccess.getModuloAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Modulo__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Modulo__Group_1__0__Impl
	rule__Modulo__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getModuloAccess().getModuloLeftAction_1_0()); }
	()
	{ after(grammarAccess.getModuloAccess().getModuloLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Modulo__Group_1__1__Impl
	rule__Modulo__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getModuloAccess().getPercentSignKeyword_1_1()); }
	'%'
	{ after(grammarAccess.getModuloAccess().getPercentSignKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Modulo__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getModuloAccess().getRightAssignment_1_2()); }
	(rule__Modulo__RightAssignment_1_2)
	{ after(grammarAccess.getModuloAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0__0__Impl
	rule__UnaryExpression__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getAlternatives_0_0()); }
	(rule__UnaryExpression__Alternatives_0_0)
	{ after(grammarAccess.getUnaryExpressionAccess().getAlternatives_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getChildAssignment_0_1()); }
	(rule__UnaryExpression__ChildAssignment_0_1)
	{ after(grammarAccess.getUnaryExpressionAccess().getChildAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_0__0__Impl
	rule__UnaryExpression__Group_0_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryPlusExpressionAction_0_0_0_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryPlusExpressionAction_0_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getPlusSignKeyword_0_0_0_1()); }
	'+'
	{ after(grammarAccess.getUnaryExpressionAccess().getPlusSignKeyword_0_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_1__0__Impl
	rule__UnaryExpression__Group_0_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryMinusExpressionAction_0_0_1_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryMinusExpressionAction_0_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getHyphenMinusKeyword_0_0_1_1()); }
	'-'
	{ after(grammarAccess.getUnaryExpressionAccess().getHyphenMinusKeyword_0_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_2__0__Impl
	rule__UnaryExpression__Group_0_0_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryNegationExpressionAction_0_0_2_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryNegationExpressionAction_0_0_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getNotKeyword_0_0_2_1()); }
	'not'
	{ after(grammarAccess.getUnaryExpressionAccess().getNotKeyword_0_0_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_3__0__Impl
	rule__UnaryExpression__Group_0_0_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryFirstExpressionAction_0_0_3_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryFirstExpressionAction_0_0_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getFirstKeyword_0_0_3_1()); }
	'first'
	{ after(grammarAccess.getUnaryExpressionAccess().getFirstKeyword_0_0_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_4__0__Impl
	rule__UnaryExpression__Group_0_0_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryLengthExpressionAction_0_0_4_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryLengthExpressionAction_0_0_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getLengthKeyword_0_0_4_1()); }
	'length'
	{ after(grammarAccess.getUnaryExpressionAccess().getLengthKeyword_0_0_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_5__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_5__0__Impl
	rule__UnaryExpression__Group_0_0_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_5__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryCoerceExpressionAction_0_0_5_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryCoerceExpressionAction_0_0_5_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_5__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_5__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getDollarSignKeyword_0_0_5_1()); }
	'$'
	{ after(grammarAccess.getUnaryExpressionAccess().getDollarSignKeyword_0_0_5_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_6__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_6__0__Impl
	rule__UnaryExpression__Group_0_0_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_6__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryFullExpressionAction_0_0_6_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryFullExpressionAction_0_0_6_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_6__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_6__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getFullKeyword_0_0_6_1()); }
	'full'
	{ after(grammarAccess.getUnaryExpressionAccess().getFullKeyword_0_0_6_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_7__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_7__0__Impl
	rule__UnaryExpression__Group_0_0_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_7__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryDeQueueExpressionAction_0_0_7_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryDeQueueExpressionAction_0_0_7_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_7__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_7__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_7__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getDequeueKeyword_0_0_7_1()); }
	'dequeue'
	{ after(grammarAccess.getUnaryExpressionAccess().getDequeueKeyword_0_0_7_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_0_0_8__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_8__0__Impl
	rule__UnaryExpression__Group_0_0_8__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_8__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryEmptyExpressionAction_0_0_8_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryEmptyExpressionAction_0_0_8_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_8__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_0_0_8__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_0_0_8__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getEmptyKeyword_0_0_8_1()); }
	'empty'
	{ after(grammarAccess.getUnaryExpressionAccess().getEmptyKeyword_0_0_8_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Projection__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Projection__Group__0__Impl
	rule__Projection__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProjectionAccess().getAtomicExpressionParserRuleCall_0()); }
	ruleAtomicExpression
	{ after(grammarAccess.getProjectionAccess().getAtomicExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Projection__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProjectionAccess().getGroup_1()); }
	(rule__Projection__Group_1__0)?
	{ after(grammarAccess.getProjectionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Projection__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Projection__Group_1__0__Impl
	rule__Projection__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProjectionAccess().getProjectionChannelAction_1_0()); }
	()
	{ after(grammarAccess.getProjectionAccess().getProjectionChannelAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Projection__Group_1__1__Impl
	rule__Projection__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProjectionAccess().getCircumflexAccentKeyword_1_1()); }
	'^'
	{ after(grammarAccess.getProjectionAccess().getCircumflexAccentKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Projection__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProjectionAccess().getFieldAssignment_1_2()); }
	(rule__Projection__FieldAssignment_1_2)
	{ after(grammarAccess.getProjectionAccess().getFieldAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AtomicExpression__Group_8__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicExpression__Group_8__0__Impl
	rule__AtomicExpression__Group_8__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_8__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_8_0()); }
	'('
	{ after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_8_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_8__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicExpression__Group_8__1__Impl
	rule__AtomicExpression__Group_8__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_8__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_8_1()); }
	ruleExpression
	{ after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_8_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_8__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicExpression__Group_8__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_8__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_8_2()); }
	')'
	{ after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_8_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ReferenceExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ReferenceExpression__Group__0__Impl
	rule__ReferenceExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ReferenceExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getReferenceExpressionAccess().getAmpersandKeyword_0()); }
	'&'
	{ after(grammarAccess.getReferenceExpressionAccess().getAmpersandKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ReferenceExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ReferenceExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ReferenceExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getReferenceExpressionAccess().getDeclarationAssignment_1()); }
	(rule__ReferenceExpression__DeclarationAssignment_1)
	{ after(grammarAccess.getReferenceExpressionAccess().getDeclarationAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierExpression__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0__0__Impl
	rule__IdentifierExpression__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getConstructionExpressionAction_0_0()); }
	()
	{ after(grammarAccess.getIdentifierExpressionAccess().getConstructionExpressionAction_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0__1__Impl
	rule__IdentifierExpression__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getDeclarationAssignment_0_1()); }
	(rule__IdentifierExpression__DeclarationAssignment_0_1)
	{ after(grammarAccess.getIdentifierExpressionAccess().getDeclarationAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0__2__Impl
	rule__IdentifierExpression__Group_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getLeftParenthesisKeyword_0_2()); }
	'('
	{ after(grammarAccess.getIdentifierExpressionAccess().getLeftParenthesisKeyword_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0__3__Impl
	rule__IdentifierExpression__Group_0__4
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getGroup_0_3()); }
	(rule__IdentifierExpression__Group_0_3__0)?
	{ after(grammarAccess.getIdentifierExpressionAccess().getGroup_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getRightParenthesisKeyword_0_4()); }
	')'
	{ after(grammarAccess.getIdentifierExpressionAccess().getRightParenthesisKeyword_0_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierExpression__Group_0_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0_3__0__Impl
	rule__IdentifierExpression__Group_0_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getParametersAssignment_0_3_0()); }
	(rule__IdentifierExpression__ParametersAssignment_0_3_0)
	{ after(grammarAccess.getIdentifierExpressionAccess().getParametersAssignment_0_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getGroup_0_3_1()); }
	(rule__IdentifierExpression__Group_0_3_1__0)*
	{ after(grammarAccess.getIdentifierExpressionAccess().getGroup_0_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierExpression__Group_0_3_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0_3_1__0__Impl
	rule__IdentifierExpression__Group_0_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0_3_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getCommaKeyword_0_3_1_0()); }
	','
	{ after(grammarAccess.getIdentifierExpressionAccess().getCommaKeyword_0_3_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0_3_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_0_3_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_0_3_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getParametersAssignment_0_3_1_1()); }
	(rule__IdentifierExpression__ParametersAssignment_0_3_1_1)
	{ after(grammarAccess.getIdentifierExpressionAccess().getParametersAssignment_0_3_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1__0__Impl
	rule__IdentifierExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getDeclarationAssignment_1_0()); }
	(rule__IdentifierExpression__DeclarationAssignment_1_0)
	{ after(grammarAccess.getIdentifierExpressionAccess().getDeclarationAssignment_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getAlternatives_1_1()); }
	(rule__IdentifierExpression__Alternatives_1_1)*
	{ after(grammarAccess.getIdentifierExpressionAccess().getAlternatives_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierExpression__Group_1_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_0__0__Impl
	rule__IdentifierExpression__Group_1_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getLeftSquareBracketKeyword_1_1_0_0()); }
	'['
	{ after(grammarAccess.getIdentifierExpressionAccess().getLeftSquareBracketKeyword_1_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_0__1__Impl
	rule__IdentifierExpression__Group_1_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getArrayAccessExpressionChildAction_1_1_0_1()); }
	()
	{ after(grammarAccess.getIdentifierExpressionAccess().getArrayAccessExpressionChildAction_1_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_0__2__Impl
	rule__IdentifierExpression__Group_1_1_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getIndexesAssignment_1_1_0_2()); }
	(rule__IdentifierExpression__IndexesAssignment_1_1_0_2)
	{ after(grammarAccess.getIdentifierExpressionAccess().getIndexesAssignment_1_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_0__3__Impl
	rule__IdentifierExpression__Group_1_1_0__4
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getGroup_1_1_0_3()); }
	(rule__IdentifierExpression__Group_1_1_0_3__0)*
	{ after(grammarAccess.getIdentifierExpressionAccess().getGroup_1_1_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_0__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getRightSquareBracketKeyword_1_1_0_4()); }
	']'
	{ after(grammarAccess.getIdentifierExpressionAccess().getRightSquareBracketKeyword_1_1_0_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierExpression__Group_1_1_0_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_0_3__0__Impl
	rule__IdentifierExpression__Group_1_1_0_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getCommaKeyword_1_1_0_3_0()); }
	','
	{ after(grammarAccess.getIdentifierExpressionAccess().getCommaKeyword_1_1_0_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_0_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_0_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getIndexesAssignment_1_1_0_3_1()); }
	(rule__IdentifierExpression__IndexesAssignment_1_1_0_3_1)
	{ after(grammarAccess.getIdentifierExpressionAccess().getIndexesAssignment_1_1_0_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__IdentifierExpression__Group_1_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_1__0__Impl
	rule__IdentifierExpression__Group_1_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getFullStopKeyword_1_1_1_0()); }
	'.'
	{ after(grammarAccess.getIdentifierExpressionAccess().getFullStopKeyword_1_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_1__1__Impl
	rule__IdentifierExpression__Group_1_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getRecordAccessExpressionChildAction_1_1_1_1()); }
	()
	{ after(grammarAccess.getIdentifierExpressionAccess().getRecordAccessExpressionChildAction_1_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__IdentifierExpression__Group_1_1_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__Group_1_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIdentifierExpressionAccess().getFieldAssignment_1_1_1_2()); }
	(rule__IdentifierExpression__FieldAssignment_1_1_1_2)
	{ after(grammarAccess.getIdentifierExpressionAccess().getFieldAssignment_1_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__RecordExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordExpression__Group__0__Impl
	rule__RecordExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordExpressionAccess().getLeftCurlyBracketKeyword_0()); }
	'{'
	{ after(grammarAccess.getRecordExpressionAccess().getLeftCurlyBracketKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordExpression__Group__1__Impl
	rule__RecordExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordExpressionAccess().getFieldsAssignment_1()); }
	(rule__RecordExpression__FieldsAssignment_1)
	{ after(grammarAccess.getRecordExpressionAccess().getFieldsAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordExpression__Group__2__Impl
	rule__RecordExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordExpressionAccess().getGroup_2()); }
	(rule__RecordExpression__Group_2__0)*
	{ after(grammarAccess.getRecordExpressionAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordExpression__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordExpressionAccess().getRightCurlyBracketKeyword_3()); }
	'}'
	{ after(grammarAccess.getRecordExpressionAccess().getRightCurlyBracketKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__RecordExpression__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordExpression__Group_2__0__Impl
	rule__RecordExpression__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordExpressionAccess().getCommaKeyword_2_0()); }
	','
	{ after(grammarAccess.getRecordExpressionAccess().getCommaKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__RecordExpression__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRecordExpressionAccess().getFieldsAssignment_2_1()); }
	(rule__RecordExpression__FieldsAssignment_2_1)
	{ after(grammarAccess.getRecordExpressionAccess().getFieldsAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__FieldExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FieldExpression__Group__0__Impl
	rule__FieldExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FieldExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldExpressionAccess().getFieldAssignment_0()); }
	(rule__FieldExpression__FieldAssignment_0)
	{ after(grammarAccess.getFieldExpressionAccess().getFieldAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FieldExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FieldExpression__Group__1__Impl
	rule__FieldExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FieldExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldExpressionAccess().getEqualsSignKeyword_1()); }
	'='
	{ after(grammarAccess.getFieldExpressionAccess().getEqualsSignKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FieldExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FieldExpression__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FieldExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldExpressionAccess().getValueAssignment_2()); }
	(rule__FieldExpression__ValueAssignment_2)
	{ after(grammarAccess.getFieldExpressionAccess().getValueAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayExpression__Group__0__Impl
	rule__ArrayExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayExpressionAccess().getArrayExpressionAction_0()); }
	()
	{ after(grammarAccess.getArrayExpressionAccess().getArrayExpressionAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayExpression__Group__1__Impl
	rule__ArrayExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayExpressionAccess().getLeftSquareBracketKeyword_1()); }
	'['
	{ after(grammarAccess.getArrayExpressionAccess().getLeftSquareBracketKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayExpression__Group__2__Impl
	rule__ArrayExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayExpressionAccess().getGroup_2()); }
	(rule__ArrayExpression__Group_2__0)?
	{ after(grammarAccess.getArrayExpressionAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayExpression__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayExpressionAccess().getRightSquareBracketKeyword_3()); }
	']'
	{ after(grammarAccess.getArrayExpressionAccess().getRightSquareBracketKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayExpression__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayExpression__Group_2__0__Impl
	rule__ArrayExpression__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayExpressionAccess().getValuesAssignment_2_0()); }
	(rule__ArrayExpression__ValuesAssignment_2_0)
	{ after(grammarAccess.getArrayExpressionAccess().getValuesAssignment_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayExpression__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayExpressionAccess().getGroup_2_1()); }
	(rule__ArrayExpression__Group_2_1__0)*
	{ after(grammarAccess.getArrayExpressionAccess().getGroup_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ArrayExpression__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayExpression__Group_2_1__0__Impl
	rule__ArrayExpression__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayExpressionAccess().getCommaKeyword_2_1_0()); }
	','
	{ after(grammarAccess.getArrayExpressionAccess().getCommaKeyword_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArrayExpression__Group_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArrayExpressionAccess().getValuesAssignment_2_1_1()); }
	(rule__ArrayExpression__ValuesAssignment_2_1_1)
	{ after(grammarAccess.getArrayExpressionAccess().getValuesAssignment_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QueueExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueExpression__Group__0__Impl
	rule__QueueExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueExpressionAccess().getQueueExpressionAction_0()); }
	()
	{ after(grammarAccess.getQueueExpressionAccess().getQueueExpressionAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueExpression__Group__1__Impl
	rule__QueueExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueExpressionAccess().getLeftCurlyBracketVerticalLineKeyword_1()); }
	'{|'
	{ after(grammarAccess.getQueueExpressionAccess().getLeftCurlyBracketVerticalLineKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueExpression__Group__2__Impl
	rule__QueueExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueExpressionAccess().getGroup_2()); }
	(rule__QueueExpression__Group_2__0)?
	{ after(grammarAccess.getQueueExpressionAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueExpression__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueExpressionAccess().getVerticalLineRightCurlyBracketKeyword_3()); }
	'|}'
	{ after(grammarAccess.getQueueExpressionAccess().getVerticalLineRightCurlyBracketKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QueueExpression__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueExpression__Group_2__0__Impl
	rule__QueueExpression__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueExpressionAccess().getValuesAssignment_2_0()); }
	(rule__QueueExpression__ValuesAssignment_2_0)
	{ after(grammarAccess.getQueueExpressionAccess().getValuesAssignment_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueExpression__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueExpressionAccess().getGroup_2_1()); }
	(rule__QueueExpression__Group_2_1__0)*
	{ after(grammarAccess.getQueueExpressionAccess().getGroup_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QueueExpression__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueExpression__Group_2_1__0__Impl
	rule__QueueExpression__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueExpressionAccess().getCommaKeyword_2_1_0()); }
	','
	{ after(grammarAccess.getQueueExpressionAccess().getCommaKeyword_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QueueExpression__Group_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQueueExpressionAccess().getValuesAssignment_2_1_1()); }
	(rule__QueueExpression__ValuesAssignment_2_1_1)
	{ after(grammarAccess.getQueueExpressionAccess().getValuesAssignment_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__EnqueueExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnqueueExpression__Group__0__Impl
	rule__EnqueueExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnqueueExpressionAccess().getEnqueueKeyword_0()); }
	'enqueue'
	{ after(grammarAccess.getEnqueueExpressionAccess().getEnqueueKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnqueueExpression__Group__1__Impl
	rule__EnqueueExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnqueueExpressionAccess().getLeftParenthesisKeyword_1()); }
	'('
	{ after(grammarAccess.getEnqueueExpressionAccess().getLeftParenthesisKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnqueueExpression__Group__2__Impl
	rule__EnqueueExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnqueueExpressionAccess().getElementAssignment_2()); }
	(rule__EnqueueExpression__ElementAssignment_2)
	{ after(grammarAccess.getEnqueueExpressionAccess().getElementAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnqueueExpression__Group__3__Impl
	rule__EnqueueExpression__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnqueueExpressionAccess().getCommaKeyword_3()); }
	','
	{ after(grammarAccess.getEnqueueExpressionAccess().getCommaKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnqueueExpression__Group__4__Impl
	rule__EnqueueExpression__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnqueueExpressionAccess().getQueueAssignment_4()); }
	(rule__EnqueueExpression__QueueAssignment_4)
	{ after(grammarAccess.getEnqueueExpressionAccess().getQueueAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnqueueExpression__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnqueueExpressionAccess().getRightParenthesisKeyword_5()); }
	')'
	{ after(grammarAccess.getEnqueueExpressionAccess().getRightParenthesisKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AppendExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AppendExpression__Group__0__Impl
	rule__AppendExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAppendExpressionAccess().getAppendKeyword_0()); }
	'append'
	{ after(grammarAccess.getAppendExpressionAccess().getAppendKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AppendExpression__Group__1__Impl
	rule__AppendExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAppendExpressionAccess().getLeftParenthesisKeyword_1()); }
	'('
	{ after(grammarAccess.getAppendExpressionAccess().getLeftParenthesisKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AppendExpression__Group__2__Impl
	rule__AppendExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAppendExpressionAccess().getLeftAssignment_2()); }
	(rule__AppendExpression__LeftAssignment_2)
	{ after(grammarAccess.getAppendExpressionAccess().getLeftAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AppendExpression__Group__3__Impl
	rule__AppendExpression__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAppendExpressionAccess().getCommaKeyword_3()); }
	','
	{ after(grammarAccess.getAppendExpressionAccess().getCommaKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AppendExpression__Group__4__Impl
	rule__AppendExpression__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAppendExpressionAccess().getRightAssignment_4()); }
	(rule__AppendExpression__RightAssignment_4)
	{ after(grammarAccess.getAppendExpressionAccess().getRightAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AppendExpression__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAppendExpressionAccess().getRightParenthesisKeyword_5()); }
	')'
	{ after(grammarAccess.getAppendExpressionAccess().getRightParenthesisKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BooleanLiteral__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BooleanLiteral__Group_0__0__Impl
	rule__BooleanLiteral__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBooleanLiteralAccess().getTrueLiteralAction_0_0()); }
	()
	{ after(grammarAccess.getBooleanLiteralAccess().getTrueLiteralAction_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BooleanLiteral__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBooleanLiteralAccess().getTrueKeyword_0_1()); }
	'true'
	{ after(grammarAccess.getBooleanLiteralAccess().getTrueKeyword_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BooleanLiteral__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BooleanLiteral__Group_1__0__Impl
	rule__BooleanLiteral__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBooleanLiteralAccess().getFalseLiteralAction_1_0()); }
	()
	{ after(grammarAccess.getBooleanLiteralAccess().getFalseLiteralAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BooleanLiteral__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_1()); }
	'false'
	{ after(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__NaturalLowerBound__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NaturalLowerBound__Group__0__Impl
	rule__NaturalLowerBound__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalLowerBound__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNaturalLowerBoundAccess().getAlternatives_0()); }
	(rule__NaturalLowerBound__Alternatives_0)
	{ after(grammarAccess.getNaturalLowerBoundAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalLowerBound__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NaturalLowerBound__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalLowerBound__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNaturalLowerBoundAccess().getValueAssignment_1()); }
	(rule__NaturalLowerBound__ValueAssignment_1)
	{ after(grammarAccess.getNaturalLowerBoundAccess().getValueAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__NaturalUpperBound__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NaturalUpperBound__Group__0__Impl
	rule__NaturalUpperBound__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalUpperBound__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNaturalUpperBoundAccess().getValueAssignment_0()); }
	(rule__NaturalUpperBound__ValueAssignment_0)
	{ after(grammarAccess.getNaturalUpperBoundAccess().getValueAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalUpperBound__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NaturalUpperBound__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalUpperBound__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNaturalUpperBoundAccess().getAlternatives_1()); }
	(rule__NaturalUpperBound__Alternatives_1)
	{ after(grammarAccess.getNaturalUpperBoundAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DecimalLowerBound__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DecimalLowerBound__Group__0__Impl
	rule__DecimalLowerBound__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalLowerBound__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDecimalLowerBoundAccess().getAlternatives_0()); }
	(rule__DecimalLowerBound__Alternatives_0)
	{ after(grammarAccess.getDecimalLowerBoundAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalLowerBound__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DecimalLowerBound__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalLowerBound__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDecimalLowerBoundAccess().getValueAssignment_1()); }
	(rule__DecimalLowerBound__ValueAssignment_1)
	{ after(grammarAccess.getDecimalLowerBoundAccess().getValueAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DecimalUpperBound__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DecimalUpperBound__Group__0__Impl
	rule__DecimalUpperBound__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalUpperBound__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDecimalUpperBoundAccess().getValueAssignment_0()); }
	(rule__DecimalUpperBound__ValueAssignment_0)
	{ after(grammarAccess.getDecimalUpperBoundAccess().getValueAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalUpperBound__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DecimalUpperBound__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalUpperBound__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDecimalUpperBoundAccess().getAlternatives_1()); }
	(rule__DecimalUpperBound__Alternatives_1)
	{ after(grammarAccess.getDecimalUpperBoundAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__VariableLowerBound__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariableLowerBound__Group__0__Impl
	rule__VariableLowerBound__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableLowerBound__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariableLowerBoundAccess().getAlternatives_0()); }
	(rule__VariableLowerBound__Alternatives_0)
	{ after(grammarAccess.getVariableLowerBoundAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableLowerBound__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariableLowerBound__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableLowerBound__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariableLowerBoundAccess().getVariableAssignment_1()); }
	(rule__VariableLowerBound__VariableAssignment_1)
	{ after(grammarAccess.getVariableLowerBoundAccess().getVariableAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__VariableUpperBound__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariableUpperBound__Group__0__Impl
	rule__VariableUpperBound__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableUpperBound__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariableUpperBoundAccess().getVariableAssignment_0()); }
	(rule__VariableUpperBound__VariableAssignment_0)
	{ after(grammarAccess.getVariableUpperBoundAccess().getVariableAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableUpperBound__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__VariableUpperBound__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableUpperBound__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getVariableUpperBoundAccess().getAlternatives_1()); }
	(rule__VariableUpperBound__Alternatives_1)
	{ after(grammarAccess.getVariableUpperBoundAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__InfiniteUpperBound__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InfiniteUpperBound__Group__0__Impl
	rule__InfiniteUpperBound__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InfiniteUpperBound__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInfiniteUpperBoundAccess().getInfiniteUpperBoundAction_0()); }
	()
	{ after(grammarAccess.getInfiniteUpperBoundAccess().getInfiniteUpperBoundAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__InfiniteUpperBound__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InfiniteUpperBound__Group__1__Impl
	rule__InfiniteUpperBound__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__InfiniteUpperBound__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInfiniteUpperBoundAccess().getFullStopFullStopFullStopKeyword_1()); }
	'...'
	{ after(grammarAccess.getInfiniteUpperBoundAccess().getFullStopFullStopFullStopKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__InfiniteUpperBound__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InfiniteUpperBound__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InfiniteUpperBound__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInfiniteUpperBoundAccess().getLeftSquareBracketKeyword_2()); }
	'['
	{ after(grammarAccess.getInfiniteUpperBoundAccess().getLeftSquareBracketKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Requirement__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Requirement__Group__0__Impl
	rule__Requirement__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRequirementAccess().getAssertKeyword_0()); }
	'assert'
	{ after(grammarAccess.getRequirementAccess().getAssertKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Requirement__Group__1__Impl
	rule__Requirement__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRequirementAccess().getPropertyAssignment_1()); }
	(rule__Requirement__PropertyAssignment_1)
	{ after(grammarAccess.getRequirementAccess().getPropertyAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Requirement__Group__2__Impl
	rule__Requirement__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRequirementAccess().getGroup_2()); }
	(rule__Requirement__Group_2__0)?
	{ after(grammarAccess.getRequirementAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Requirement__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRequirementAccess().getGroup_3()); }
	(rule__Requirement__Group_3__0)?
	{ after(grammarAccess.getRequirementAccess().getGroup_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Requirement__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Requirement__Group_2__0__Impl
	rule__Requirement__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRequirementAccess().getTrueKeyword_2_0()); }
	'-true'
	{ after(grammarAccess.getRequirementAccess().getTrueKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Requirement__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRequirementAccess().getPositiveAssignment_2_1()); }
	(rule__Requirement__PositiveAssignment_2_1)
	{ after(grammarAccess.getRequirementAccess().getPositiveAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Requirement__Group_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Requirement__Group_3__0__Impl
	rule__Requirement__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRequirementAccess().getFalseKeyword_3_0()); }
	'-false'
	{ after(grammarAccess.getRequirementAccess().getFalseKeyword_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Requirement__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__Group_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRequirementAccess().getNegativeAssignment_3_1()); }
	(rule__Requirement__NegativeAssignment_3_1)
	{ after(grammarAccess.getRequirementAccess().getNegativeAssignment_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PropertyDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDeclaration__Group__0__Impl
	rule__PropertyDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDeclarationAccess().getPropertyKeyword_0()); }
	'property'
	{ after(grammarAccess.getPropertyDeclarationAccess().getPropertyKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDeclaration__Group__1__Impl
	rule__PropertyDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDeclarationAccess().getNameAssignment_1()); }
	(rule__PropertyDeclaration__NameAssignment_1)
	{ after(grammarAccess.getPropertyDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDeclaration__Group__2__Impl
	rule__PropertyDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDeclarationAccess().getIsKeyword_2()); }
	'is'
	{ after(grammarAccess.getPropertyDeclarationAccess().getIsKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDeclaration__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDeclarationAccess().getPropertyAssignment_3()); }
	(rule__PropertyDeclaration__PropertyAssignment_3)
	{ after(grammarAccess.getPropertyDeclarationAccess().getPropertyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QuantifiedProperty__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0__0__Impl
	rule__QuantifiedProperty__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getAlternatives_0_0()); }
	(rule__QuantifiedProperty__Alternatives_0_0)
	{ after(grammarAccess.getQuantifiedPropertyAccess().getAlternatives_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0__1__Impl
	rule__QuantifiedProperty__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getVariableAssignment_0_1()); }
	(rule__QuantifiedProperty__VariableAssignment_0_1)
	{ after(grammarAccess.getQuantifiedPropertyAccess().getVariableAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0__2__Impl
	rule__QuantifiedProperty__Group_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getInKeyword_0_2()); }
	'in'
	{ after(grammarAccess.getQuantifiedPropertyAccess().getInKeyword_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0__3__Impl
	rule__QuantifiedProperty__Group_0__4
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getTypeAssignment_0_3()); }
	(rule__QuantifiedProperty__TypeAssignment_0_3)
	{ after(grammarAccess.getQuantifiedPropertyAccess().getTypeAssignment_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0__4__Impl
	rule__QuantifiedProperty__Group_0__5
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getFullStopKeyword_0_4()); }
	'.'
	{ after(grammarAccess.getQuantifiedPropertyAccess().getFullStopKeyword_0_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getChildAssignment_0_5()); }
	(rule__QuantifiedProperty__ChildAssignment_0_5)
	{ after(grammarAccess.getQuantifiedPropertyAccess().getChildAssignment_0_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QuantifiedProperty__Group_0_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0_0_0__0__Impl
	rule__QuantifiedProperty__Group_0_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getAllPropertyAction_0_0_0_0()); }
	()
	{ after(grammarAccess.getQuantifiedPropertyAccess().getAllPropertyAction_0_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getAllKeyword_0_0_0_1()); }
	'all'
	{ after(grammarAccess.getQuantifiedPropertyAccess().getAllKeyword_0_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QuantifiedProperty__Group_0_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0_0_1__0__Impl
	rule__QuantifiedProperty__Group_0_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getExistsPropertyAction_0_0_1_0()); }
	()
	{ after(grammarAccess.getQuantifiedPropertyAccess().getExistsPropertyAction_0_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QuantifiedProperty__Group_0_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__Group_0_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQuantifiedPropertyAccess().getExistsKeyword_0_0_1_1()); }
	'exists'
	{ after(grammarAccess.getQuantifiedPropertyAccess().getExistsKeyword_0_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PropertyDisjunction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDisjunction__Group__0__Impl
	rule__PropertyDisjunction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDisjunctionAccess().getPropertyImplicationParserRuleCall_0()); }
	rulePropertyImplication
	{ after(grammarAccess.getPropertyDisjunctionAccess().getPropertyImplicationParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDisjunction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDisjunctionAccess().getGroup_1()); }
	(rule__PropertyDisjunction__Group_1__0)*
	{ after(grammarAccess.getPropertyDisjunctionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PropertyDisjunction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDisjunction__Group_1__0__Impl
	rule__PropertyDisjunction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDisjunctionAccess().getPropertyDisjunctionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getPropertyDisjunctionAccess().getPropertyDisjunctionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDisjunction__Group_1__1__Impl
	rule__PropertyDisjunction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDisjunctionAccess().getOrKeyword_1_1()); }
	'or'
	{ after(grammarAccess.getPropertyDisjunctionAccess().getOrKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyDisjunction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyDisjunctionAccess().getRightAssignment_1_2()); }
	(rule__PropertyDisjunction__RightAssignment_1_2)
	{ after(grammarAccess.getPropertyDisjunctionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PropertyImplication__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyImplication__Group__0__Impl
	rule__PropertyImplication__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyImplicationAccess().getPropertyConjunctionParserRuleCall_0()); }
	rulePropertyConjunction
	{ after(grammarAccess.getPropertyImplicationAccess().getPropertyConjunctionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyImplication__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyImplicationAccess().getGroup_1()); }
	(rule__PropertyImplication__Group_1__0)?
	{ after(grammarAccess.getPropertyImplicationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PropertyImplication__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyImplication__Group_1__0__Impl
	rule__PropertyImplication__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyImplicationAccess().getPropertyImplicationLeftAction_1_0()); }
	()
	{ after(grammarAccess.getPropertyImplicationAccess().getPropertyImplicationLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyImplication__Group_1__1__Impl
	rule__PropertyImplication__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyImplicationAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
	'=>'
	{ after(grammarAccess.getPropertyImplicationAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyImplication__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyImplicationAccess().getRightAssignment_1_2()); }
	(rule__PropertyImplication__RightAssignment_1_2)
	{ after(grammarAccess.getPropertyImplicationAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PropertyConjunction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyConjunction__Group__0__Impl
	rule__PropertyConjunction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyConjunctionAccess().getPropertyNegationParserRuleCall_0()); }
	rulePropertyNegation
	{ after(grammarAccess.getPropertyConjunctionAccess().getPropertyNegationParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyConjunction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyConjunctionAccess().getGroup_1()); }
	(rule__PropertyConjunction__Group_1__0)*
	{ after(grammarAccess.getPropertyConjunctionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PropertyConjunction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyConjunction__Group_1__0__Impl
	rule__PropertyConjunction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyConjunctionAccess().getPropertyConjunctionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getPropertyConjunctionAccess().getPropertyConjunctionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyConjunction__Group_1__1__Impl
	rule__PropertyConjunction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyConjunctionAccess().getAndKeyword_1_1()); }
	'and'
	{ after(grammarAccess.getPropertyConjunctionAccess().getAndKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyConjunction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyConjunctionAccess().getRightAssignment_1_2()); }
	(rule__PropertyConjunction__RightAssignment_1_2)
	{ after(grammarAccess.getPropertyConjunctionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PropertyNegation__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyNegation__Group_0__0__Impl
	rule__PropertyNegation__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyNegation__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyNegationAccess().getPropertyNegationAction_0_0()); }
	()
	{ after(grammarAccess.getPropertyNegationAccess().getPropertyNegationAction_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyNegation__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyNegation__Group_0__1__Impl
	rule__PropertyNegation__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyNegation__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyNegationAccess().getNotKeyword_0_1()); }
	'not'
	{ after(grammarAccess.getPropertyNegationAccess().getNotKeyword_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyNegation__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PropertyNegation__Group_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyNegation__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPropertyNegationAccess().getChildAssignment_0_2()); }
	(rule__PropertyNegation__ChildAssignment_0_2)
	{ after(grammarAccess.getPropertyNegationAccess().getChildAssignment_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AtomicProperty__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicProperty__Group_1__0__Impl
	rule__AtomicProperty__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicProperty__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicPropertyAccess().getLeftParenthesisKeyword_1_0()); }
	'('
	{ after(grammarAccess.getAtomicPropertyAccess().getLeftParenthesisKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicProperty__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicProperty__Group_1__1__Impl
	rule__AtomicProperty__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicProperty__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicPropertyAccess().getPropertyParserRuleCall_1_1()); }
	ruleProperty
	{ after(grammarAccess.getAtomicPropertyAccess().getPropertyParserRuleCall_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicProperty__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicProperty__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicProperty__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicPropertyAccess().getRightParenthesisKeyword_1_2()); }
	')'
	{ after(grammarAccess.getAtomicPropertyAccess().getRightParenthesisKeyword_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLPattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLPattern__Group__0__Impl
	rule__LTLPattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLPattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLPatternAccess().getLtlKeyword_0()); }
	'ltl'
	{ after(grammarAccess.getLTLPatternAccess().getLtlKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLPattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLPattern__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLPattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLPatternAccess().getPropertyAssignment_1()); }
	(rule__LTLPattern__PropertyAssignment_1)
	{ after(grammarAccess.getLTLPatternAccess().getPropertyAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DeadlockFreePattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DeadlockFreePattern__Group__0__Impl
	rule__DeadlockFreePattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DeadlockFreePattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDeadlockFreePatternAccess().getDeadlockFreePatternAction_0()); }
	()
	{ after(grammarAccess.getDeadlockFreePatternAccess().getDeadlockFreePatternAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DeadlockFreePattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DeadlockFreePattern__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DeadlockFreePattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDeadlockFreePatternAccess().getDeadlockfreeKeyword_1()); }
	'deadlockfree'
	{ after(grammarAccess.getDeadlockFreePatternAccess().getDeadlockfreeKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__InfinitelyOftenPattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InfinitelyOftenPattern__Group__0__Impl
	rule__InfinitelyOftenPattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InfinitelyOftenPattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInfinitelyOftenPatternAccess().getInfinitelyoftenKeyword_0()); }
	'infinitelyoften'
	{ after(grammarAccess.getInfinitelyOftenPatternAccess().getInfinitelyoftenKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__InfinitelyOftenPattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InfinitelyOftenPattern__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InfinitelyOftenPattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInfinitelyOftenPatternAccess().getSubjectAssignment_1()); }
	(rule__InfinitelyOftenPattern__SubjectAssignment_1)
	{ after(grammarAccess.getInfinitelyOftenPatternAccess().getSubjectAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__MortalPattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MortalPattern__Group__0__Impl
	rule__MortalPattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MortalPattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMortalPatternAccess().getMortalKeyword_0()); }
	'mortal'
	{ after(grammarAccess.getMortalPatternAccess().getMortalKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MortalPattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MortalPattern__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MortalPattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMortalPatternAccess().getSubjectAssignment_1()); }
	(rule__MortalPattern__SubjectAssignment_1)
	{ after(grammarAccess.getMortalPatternAccess().getSubjectAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group__0__Impl
	rule__PresencePattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getPresentKeyword_0()); }
	'present'
	{ after(grammarAccess.getPresencePatternAccess().getPresentKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group__1__Impl
	rule__PresencePattern__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getSubjectAssignment_1()); }
	(rule__PresencePattern__SubjectAssignment_1)
	{ after(grammarAccess.getPresencePatternAccess().getSubjectAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getAlternatives_2()); }
	(rule__PresencePattern__Alternatives_2)?
	{ after(grammarAccess.getPresencePatternAccess().getAlternatives_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_0__0__Impl
	rule__PresencePattern__Group_2_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getLastingKeyword_2_0_0()); }
	'lasting'
	{ after(grammarAccess.getPresencePatternAccess().getLastingKeyword_2_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getLastingAssignment_2_0_1()); }
	(rule__PresencePattern__LastingAssignment_2_0_1)
	{ after(grammarAccess.getPresencePatternAccess().getLastingAssignment_2_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1__0__Impl
	rule__PresencePattern__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getGroup_2_1_0()); }
	(rule__PresencePattern__Group_2_1_0__0)
	{ after(grammarAccess.getPresencePatternAccess().getGroup_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getAlternatives_2_1_1()); }
	(rule__PresencePattern__Alternatives_2_1_1)?
	{ after(grammarAccess.getPresencePatternAccess().getAlternatives_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1_0__0__Impl
	rule__PresencePattern__Group_2_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getAfterKeyword_2_1_0_0()); }
	'after'
	{ after(grammarAccess.getPresencePatternAccess().getAfterKeyword_2_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getAfterAssignment_2_1_0_1()); }
	(rule__PresencePattern__AfterAssignment_2_1_0_1)
	{ after(grammarAccess.getPresencePatternAccess().getAfterAssignment_2_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_1_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1_1_0__0__Impl
	rule__PresencePattern__Group_2_1_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getWithinKeyword_2_1_1_0_0()); }
	'within'
	{ after(grammarAccess.getPresencePatternAccess().getWithinKeyword_2_1_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1_1_0__1__Impl
	rule__PresencePattern__Group_2_1_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getLowerAssignment_2_1_1_0_1()); }
	(rule__PresencePattern__LowerAssignment_2_1_1_0_1)
	{ after(grammarAccess.getPresencePatternAccess().getLowerAssignment_2_1_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1_1_0__2__Impl
	rule__PresencePattern__Group_2_1_1_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getCommaKeyword_2_1_1_0_2()); }
	','
	{ after(grammarAccess.getPresencePatternAccess().getCommaKeyword_2_1_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1_1_0__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getUpperAssignment_2_1_1_0_3()); }
	(rule__PresencePattern__UpperAssignment_2_1_1_0_3)
	{ after(grammarAccess.getPresencePatternAccess().getUpperAssignment_2_1_1_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_1_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1_1_1__0__Impl
	rule__PresencePattern__Group_2_1_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getUntilKeyword_2_1_1_1_0()); }
	'until'
	{ after(grammarAccess.getPresencePatternAccess().getUntilKeyword_2_1_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_1_1_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_1_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getUntilAssignment_2_1_1_1_1()); }
	(rule__PresencePattern__UntilAssignment_2_1_1_1_1)
	{ after(grammarAccess.getPresencePatternAccess().getUntilAssignment_2_1_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_2__0__Impl
	rule__PresencePattern__Group_2_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getGroup_2_2_0()); }
	(rule__PresencePattern__Group_2_2_0__0)
	{ after(grammarAccess.getPresencePatternAccess().getGroup_2_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getGroup_2_2_1()); }
	(rule__PresencePattern__Group_2_2_1__0)?
	{ after(grammarAccess.getPresencePatternAccess().getGroup_2_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_2_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_2_0__0__Impl
	rule__PresencePattern__Group_2_2_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getBeforeKeyword_2_2_0_0()); }
	'before'
	{ after(grammarAccess.getPresencePatternAccess().getBeforeKeyword_2_2_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_2_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getBeforeAssignment_2_2_0_1()); }
	(rule__PresencePattern__BeforeAssignment_2_2_0_1)
	{ after(grammarAccess.getPresencePatternAccess().getBeforeAssignment_2_2_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_2_1__0__Impl
	rule__PresencePattern__Group_2_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getWithinKeyword_2_2_1_0()); }
	'within'
	{ after(grammarAccess.getPresencePatternAccess().getWithinKeyword_2_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_2_1__1__Impl
	rule__PresencePattern__Group_2_2_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getLowerAssignment_2_2_1_1()); }
	(rule__PresencePattern__LowerAssignment_2_2_1_1)
	{ after(grammarAccess.getPresencePatternAccess().getLowerAssignment_2_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_2_1__2__Impl
	rule__PresencePattern__Group_2_2_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getCommaKeyword_2_2_1_2()); }
	','
	{ after(grammarAccess.getPresencePatternAccess().getCommaKeyword_2_2_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_2_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_2_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getUpperAssignment_2_2_1_3()); }
	(rule__PresencePattern__UpperAssignment_2_2_1_3)
	{ after(grammarAccess.getPresencePatternAccess().getUpperAssignment_2_2_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PresencePattern__Group_2_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_3__0__Impl
	rule__PresencePattern__Group_2_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getBetweenKeyword_2_3_0()); }
	'between'
	{ after(grammarAccess.getPresencePatternAccess().getBetweenKeyword_2_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_3__1__Impl
	rule__PresencePattern__Group_2_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getMinAssignment_2_3_1()); }
	(rule__PresencePattern__MinAssignment_2_3_1)
	{ after(grammarAccess.getPresencePatternAccess().getMinAssignment_2_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_3__2__Impl
	rule__PresencePattern__Group_2_3__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getAndKeyword_2_3_2()); }
	'and'
	{ after(grammarAccess.getPresencePatternAccess().getAndKeyword_2_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_3__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PresencePattern__Group_2_3__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__Group_2_3__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPresencePatternAccess().getMaxAssignment_2_3_3()); }
	(rule__PresencePattern__MaxAssignment_2_3_3)
	{ after(grammarAccess.getPresencePatternAccess().getMaxAssignment_2_3_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group__0__Impl
	rule__AbsencePattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getAbsentKeyword_0()); }
	'absent'
	{ after(grammarAccess.getAbsencePatternAccess().getAbsentKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group__1__Impl
	rule__AbsencePattern__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getSubjectAssignment_1()); }
	(rule__AbsencePattern__SubjectAssignment_1)
	{ after(grammarAccess.getAbsencePatternAccess().getSubjectAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getAlternatives_2()); }
	(rule__AbsencePattern__Alternatives_2)?
	{ after(grammarAccess.getAbsencePatternAccess().getAlternatives_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group_2_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0__0__Impl
	rule__AbsencePattern__Group_2_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getGroup_2_0_0()); }
	(rule__AbsencePattern__Group_2_0_0__0)
	{ after(grammarAccess.getAbsencePatternAccess().getGroup_2_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getAlternatives_2_0_1()); }
	(rule__AbsencePattern__Alternatives_2_0_1)?
	{ after(grammarAccess.getAbsencePatternAccess().getAlternatives_2_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group_2_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0_0__0__Impl
	rule__AbsencePattern__Group_2_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getAfterKeyword_2_0_0_0()); }
	'after'
	{ after(grammarAccess.getAbsencePatternAccess().getAfterKeyword_2_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getAfterAssignment_2_0_0_1()); }
	(rule__AbsencePattern__AfterAssignment_2_0_0_1)
	{ after(grammarAccess.getAbsencePatternAccess().getAfterAssignment_2_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group_2_0_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0_1_0__0__Impl
	rule__AbsencePattern__Group_2_0_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getWithinKeyword_2_0_1_0_0()); }
	'within'
	{ after(grammarAccess.getAbsencePatternAccess().getWithinKeyword_2_0_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0_1_0__1__Impl
	rule__AbsencePattern__Group_2_0_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getLowerAssignment_2_0_1_0_1()); }
	(rule__AbsencePattern__LowerAssignment_2_0_1_0_1)
	{ after(grammarAccess.getAbsencePatternAccess().getLowerAssignment_2_0_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0_1_0__2__Impl
	rule__AbsencePattern__Group_2_0_1_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getCommaKeyword_2_0_1_0_2()); }
	','
	{ after(grammarAccess.getAbsencePatternAccess().getCommaKeyword_2_0_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0_1_0__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getUpperAssignment_2_0_1_0_3()); }
	(rule__AbsencePattern__UpperAssignment_2_0_1_0_3)
	{ after(grammarAccess.getAbsencePatternAccess().getUpperAssignment_2_0_1_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group_2_0_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0_1_1__0__Impl
	rule__AbsencePattern__Group_2_0_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getUntilKeyword_2_0_1_1_0()); }
	'until'
	{ after(grammarAccess.getAbsencePatternAccess().getUntilKeyword_2_0_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_0_1_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_0_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getUntilAssignment_2_0_1_1_1()); }
	(rule__AbsencePattern__UntilAssignment_2_0_1_1_1)
	{ after(grammarAccess.getAbsencePatternAccess().getUntilAssignment_2_0_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_1__0__Impl
	rule__AbsencePattern__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getGroup_2_1_0()); }
	(rule__AbsencePattern__Group_2_1_0__0)
	{ after(grammarAccess.getAbsencePatternAccess().getGroup_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getGroup_2_1_1()); }
	(rule__AbsencePattern__Group_2_1_1__0)?
	{ after(grammarAccess.getAbsencePatternAccess().getGroup_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group_2_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_1_0__0__Impl
	rule__AbsencePattern__Group_2_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getBeforeKeyword_2_1_0_0()); }
	'before'
	{ after(grammarAccess.getAbsencePatternAccess().getBeforeKeyword_2_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_1_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getBeforeAssignment_2_1_0_1()); }
	(rule__AbsencePattern__BeforeAssignment_2_1_0_1)
	{ after(grammarAccess.getAbsencePatternAccess().getBeforeAssignment_2_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group_2_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_1_1__0__Impl
	rule__AbsencePattern__Group_2_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getForKeyword_2_1_1_0()); }
	'for'
	{ after(grammarAccess.getAbsencePatternAccess().getForKeyword_2_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_1_1__1__Impl
	rule__AbsencePattern__Group_2_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getLowerAssignment_2_1_1_1()); }
	(rule__AbsencePattern__LowerAssignment_2_1_1_1)
	{ after(grammarAccess.getAbsencePatternAccess().getLowerAssignment_2_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_1_1__2__Impl
	rule__AbsencePattern__Group_2_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getCommaKeyword_2_1_1_2()); }
	','
	{ after(grammarAccess.getAbsencePatternAccess().getCommaKeyword_2_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_1_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_1_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getUpperAssignment_2_1_1_3()); }
	(rule__AbsencePattern__UpperAssignment_2_1_1_3)
	{ after(grammarAccess.getAbsencePatternAccess().getUpperAssignment_2_1_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AbsencePattern__Group_2_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_2__0__Impl
	rule__AbsencePattern__Group_2_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getBetweenKeyword_2_2_0()); }
	'between'
	{ after(grammarAccess.getAbsencePatternAccess().getBetweenKeyword_2_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_2__1__Impl
	rule__AbsencePattern__Group_2_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getMinAssignment_2_2_1()); }
	(rule__AbsencePattern__MinAssignment_2_2_1)
	{ after(grammarAccess.getAbsencePatternAccess().getMinAssignment_2_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_2__2__Impl
	rule__AbsencePattern__Group_2_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getAndKeyword_2_2_2()); }
	'and'
	{ after(grammarAccess.getAbsencePatternAccess().getAndKeyword_2_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AbsencePattern__Group_2_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__Group_2_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAbsencePatternAccess().getMaxAssignment_2_2_3()); }
	(rule__AbsencePattern__MaxAssignment_2_2_3)
	{ after(grammarAccess.getAbsencePatternAccess().getMaxAssignment_2_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AlwaysPattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group__0__Impl
	rule__AlwaysPattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getAlwaysKeyword_0()); }
	'always'
	{ after(grammarAccess.getAlwaysPatternAccess().getAlwaysKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group__1__Impl
	rule__AlwaysPattern__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getSubjectAssignment_1()); }
	(rule__AlwaysPattern__SubjectAssignment_1)
	{ after(grammarAccess.getAlwaysPatternAccess().getSubjectAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getAlternatives_2()); }
	(rule__AlwaysPattern__Alternatives_2)?
	{ after(grammarAccess.getAlwaysPatternAccess().getAlternatives_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AlwaysPattern__Group_2_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_0__0__Impl
	rule__AlwaysPattern__Group_2_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getBeforeKeyword_2_0_0()); }
	'before'
	{ after(grammarAccess.getAlwaysPatternAccess().getBeforeKeyword_2_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getBeforeAssignment_2_0_1()); }
	(rule__AlwaysPattern__BeforeAssignment_2_0_1)
	{ after(grammarAccess.getAlwaysPatternAccess().getBeforeAssignment_2_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AlwaysPattern__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_1__0__Impl
	rule__AlwaysPattern__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getAfterKeyword_2_1_0()); }
	'after'
	{ after(grammarAccess.getAlwaysPatternAccess().getAfterKeyword_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_1__1__Impl
	rule__AlwaysPattern__Group_2_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getAfterAssignment_2_1_1()); }
	(rule__AlwaysPattern__AfterAssignment_2_1_1)
	{ after(grammarAccess.getAlwaysPatternAccess().getAfterAssignment_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getGroup_2_1_2()); }
	(rule__AlwaysPattern__Group_2_1_2__0)?
	{ after(grammarAccess.getAlwaysPatternAccess().getGroup_2_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AlwaysPattern__Group_2_1_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_1_2__0__Impl
	rule__AlwaysPattern__Group_2_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_1_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getUntilKeyword_2_1_2_0()); }
	'until'
	{ after(grammarAccess.getAlwaysPatternAccess().getUntilKeyword_2_1_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_1_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_1_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getUntilAssignment_2_1_2_1()); }
	(rule__AlwaysPattern__UntilAssignment_2_1_2_1)
	{ after(grammarAccess.getAlwaysPatternAccess().getUntilAssignment_2_1_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AlwaysPattern__Group_2_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_2__0__Impl
	rule__AlwaysPattern__Group_2_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getBetweenKeyword_2_2_0()); }
	'between'
	{ after(grammarAccess.getAlwaysPatternAccess().getBetweenKeyword_2_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_2__1__Impl
	rule__AlwaysPattern__Group_2_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getMinAssignment_2_2_1()); }
	(rule__AlwaysPattern__MinAssignment_2_2_1)
	{ after(grammarAccess.getAlwaysPatternAccess().getMinAssignment_2_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_2__2__Impl
	rule__AlwaysPattern__Group_2_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getAndKeyword_2_2_2()); }
	'and'
	{ after(grammarAccess.getAlwaysPatternAccess().getAndKeyword_2_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AlwaysPattern__Group_2_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__Group_2_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAlwaysPatternAccess().getMaxAssignment_2_2_3()); }
	(rule__AlwaysPattern__MaxAssignment_2_2_3)
	{ after(grammarAccess.getAlwaysPatternAccess().getMaxAssignment_2_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group__0__Impl
	rule__SequencePattern__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAtomicObservableParserRuleCall_0()); }
	ruleAtomicObservable
	{ after(grammarAccess.getSequencePatternAccess().getAtomicObservableParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAlternatives_1()); }
	(rule__SequencePattern__Alternatives_1)
	{ after(grammarAccess.getSequencePatternAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0__0__Impl
	rule__SequencePattern__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getLeadstoKeyword_1_0_0()); }
	'leadsto'
	{ after(grammarAccess.getSequencePatternAccess().getLeadstoKeyword_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0__1__Impl
	rule__SequencePattern__Group_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getLeadsToPatternSubjectAction_1_0_1()); }
	()
	{ after(grammarAccess.getSequencePatternAccess().getLeadsToPatternSubjectAction_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0__2__Impl
	rule__SequencePattern__Group_1_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getFollowerAssignment_1_0_2()); }
	(rule__SequencePattern__FollowerAssignment_1_0_2)
	{ after(grammarAccess.getSequencePatternAccess().getFollowerAssignment_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAlternatives_1_0_3()); }
	(rule__SequencePattern__Alternatives_1_0_3)?
	{ after(grammarAccess.getSequencePatternAccess().getAlternatives_1_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_0_3_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_0__0__Impl
	rule__SequencePattern__Group_1_0_3_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getBeforeKeyword_1_0_3_0_0()); }
	'before'
	{ after(grammarAccess.getSequencePatternAccess().getBeforeKeyword_1_0_3_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_0__1__Impl
	rule__SequencePattern__Group_1_0_3_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getBeforeAssignment_1_0_3_0_1()); }
	(rule__SequencePattern__BeforeAssignment_1_0_3_0_1)
	{ after(grammarAccess.getSequencePatternAccess().getBeforeAssignment_1_0_3_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_0_2()); }
	(rule__SequencePattern__Group_1_0_3_0_2__0)?
	{ after(grammarAccess.getSequencePatternAccess().getGroup_1_0_3_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_0_3_0_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_0_2__0__Impl
	rule__SequencePattern__Group_1_0_3_0_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getWithinKeyword_1_0_3_0_2_0()); }
	'within'
	{ after(grammarAccess.getSequencePatternAccess().getWithinKeyword_1_0_3_0_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_0_2__1__Impl
	rule__SequencePattern__Group_1_0_3_0_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getLowerAssignment_1_0_3_0_2_1()); }
	(rule__SequencePattern__LowerAssignment_1_0_3_0_2_1)
	{ after(grammarAccess.getSequencePatternAccess().getLowerAssignment_1_0_3_0_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_0_2__2__Impl
	rule__SequencePattern__Group_1_0_3_0_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getCommaKeyword_1_0_3_0_2_2()); }
	','
	{ after(grammarAccess.getSequencePatternAccess().getCommaKeyword_1_0_3_0_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_0_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_0_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getUpperAssignment_1_0_3_0_2_3()); }
	(rule__SequencePattern__UpperAssignment_1_0_3_0_2_3)
	{ after(grammarAccess.getSequencePatternAccess().getUpperAssignment_1_0_3_0_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_0_3_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_1__0__Impl
	rule__SequencePattern__Group_1_0_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getWithinKeyword_1_0_3_1_0()); }
	'within'
	{ after(grammarAccess.getSequencePatternAccess().getWithinKeyword_1_0_3_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_1__1__Impl
	rule__SequencePattern__Group_1_0_3_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getLowerAssignment_1_0_3_1_1()); }
	(rule__SequencePattern__LowerAssignment_1_0_3_1_1)
	{ after(grammarAccess.getSequencePatternAccess().getLowerAssignment_1_0_3_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_1__2__Impl
	rule__SequencePattern__Group_1_0_3_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getCommaKeyword_1_0_3_1_2()); }
	','
	{ after(grammarAccess.getSequencePatternAccess().getCommaKeyword_1_0_3_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getUpperAssignment_1_0_3_1_3()); }
	(rule__SequencePattern__UpperAssignment_1_0_3_1_3)
	{ after(grammarAccess.getSequencePatternAccess().getUpperAssignment_1_0_3_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_0_3_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2__0__Impl
	rule__SequencePattern__Group_1_0_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAfterKeyword_1_0_3_2_0()); }
	'after'
	{ after(grammarAccess.getSequencePatternAccess().getAfterKeyword_1_0_3_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2__1__Impl
	rule__SequencePattern__Group_1_0_3_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAfterAssignment_1_0_3_2_1()); }
	(rule__SequencePattern__AfterAssignment_1_0_3_2_1)
	{ after(grammarAccess.getSequencePatternAccess().getAfterAssignment_1_0_3_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAlternatives_1_0_3_2_2()); }
	(rule__SequencePattern__Alternatives_1_0_3_2_2)?
	{ after(grammarAccess.getSequencePatternAccess().getAlternatives_1_0_3_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_0_3_2_2_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2_2_0__0__Impl
	rule__SequencePattern__Group_1_0_3_2_2_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getWithinKeyword_1_0_3_2_2_0_0()); }
	'within'
	{ after(grammarAccess.getSequencePatternAccess().getWithinKeyword_1_0_3_2_2_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2_2_0__1__Impl
	rule__SequencePattern__Group_1_0_3_2_2_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getLowerAssignment_1_0_3_2_2_0_1()); }
	(rule__SequencePattern__LowerAssignment_1_0_3_2_2_0_1)
	{ after(grammarAccess.getSequencePatternAccess().getLowerAssignment_1_0_3_2_2_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2_2_0__2__Impl
	rule__SequencePattern__Group_1_0_3_2_2_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getCommaKeyword_1_0_3_2_2_0_2()); }
	','
	{ after(grammarAccess.getSequencePatternAccess().getCommaKeyword_1_0_3_2_2_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2_2_0__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getUpperAssignment_1_0_3_2_2_0_3()); }
	(rule__SequencePattern__UpperAssignment_1_0_3_2_2_0_3)
	{ after(grammarAccess.getSequencePatternAccess().getUpperAssignment_1_0_3_2_2_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_0_3_2_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2_2_1__0__Impl
	rule__SequencePattern__Group_1_0_3_2_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getUntilKeyword_1_0_3_2_2_1_0()); }
	'until'
	{ after(grammarAccess.getSequencePatternAccess().getUntilKeyword_1_0_3_2_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_2_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_2_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getUntilAssignment_1_0_3_2_2_1_1()); }
	(rule__SequencePattern__UntilAssignment_1_0_3_2_2_1_1)
	{ after(grammarAccess.getSequencePatternAccess().getUntilAssignment_1_0_3_2_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_0_3_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_3__0__Impl
	rule__SequencePattern__Group_1_0_3_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getBetweenKeyword_1_0_3_3_0()); }
	'between'
	{ after(grammarAccess.getSequencePatternAccess().getBetweenKeyword_1_0_3_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_3__1__Impl
	rule__SequencePattern__Group_1_0_3_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getMinAssignment_1_0_3_3_1()); }
	(rule__SequencePattern__MinAssignment_1_0_3_3_1)
	{ after(grammarAccess.getSequencePatternAccess().getMinAssignment_1_0_3_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_3__2__Impl
	rule__SequencePattern__Group_1_0_3_3__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAndKeyword_1_0_3_3_2()); }
	'and'
	{ after(grammarAccess.getSequencePatternAccess().getAndKeyword_1_0_3_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_3__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_0_3_3__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_0_3_3__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getMaxAssignment_1_0_3_3_3()); }
	(rule__SequencePattern__MaxAssignment_1_0_3_3_3)
	{ after(grammarAccess.getSequencePatternAccess().getMaxAssignment_1_0_3_3_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1__0__Impl
	rule__SequencePattern__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getPrecedesKeyword_1_1_0()); }
	'precedes'
	{ after(grammarAccess.getSequencePatternAccess().getPrecedesKeyword_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1__1__Impl
	rule__SequencePattern__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getPrecedesPatternSubjectAction_1_1_1()); }
	()
	{ after(grammarAccess.getSequencePatternAccess().getPrecedesPatternSubjectAction_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1__2__Impl
	rule__SequencePattern__Group_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getFollowerAssignment_1_1_2()); }
	(rule__SequencePattern__FollowerAssignment_1_1_2)
	{ after(grammarAccess.getSequencePatternAccess().getFollowerAssignment_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAlternatives_1_1_3()); }
	(rule__SequencePattern__Alternatives_1_1_3)?
	{ after(grammarAccess.getSequencePatternAccess().getAlternatives_1_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_1_3_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_0__0__Impl
	rule__SequencePattern__Group_1_1_3_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getBeforeKeyword_1_1_3_0_0()); }
	'before'
	{ after(grammarAccess.getSequencePatternAccess().getBeforeKeyword_1_1_3_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getBeforeAssignment_1_1_3_0_1()); }
	(rule__SequencePattern__BeforeAssignment_1_1_3_0_1)
	{ after(grammarAccess.getSequencePatternAccess().getBeforeAssignment_1_1_3_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_1_3_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_1__0__Impl
	rule__SequencePattern__Group_1_1_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAfterKeyword_1_1_3_1_0()); }
	'after'
	{ after(grammarAccess.getSequencePatternAccess().getAfterKeyword_1_1_3_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_1__1__Impl
	rule__SequencePattern__Group_1_1_3_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAfterAssignment_1_1_3_1_1()); }
	(rule__SequencePattern__AfterAssignment_1_1_3_1_1)
	{ after(grammarAccess.getSequencePatternAccess().getAfterAssignment_1_1_3_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getGroup_1_1_3_1_2()); }
	(rule__SequencePattern__Group_1_1_3_1_2__0)?
	{ after(grammarAccess.getSequencePatternAccess().getGroup_1_1_3_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_1_3_1_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_1_2__0__Impl
	rule__SequencePattern__Group_1_1_3_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_1_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getUntilKeyword_1_1_3_1_2_0()); }
	'until'
	{ after(grammarAccess.getSequencePatternAccess().getUntilKeyword_1_1_3_1_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_1_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_1_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getUntilAssignment_1_1_3_1_2_1()); }
	(rule__SequencePattern__UntilAssignment_1_1_3_1_2_1)
	{ after(grammarAccess.getSequencePatternAccess().getUntilAssignment_1_1_3_1_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__SequencePattern__Group_1_1_3_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_2__0__Impl
	rule__SequencePattern__Group_1_1_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getBetweenKeyword_1_1_3_2_0()); }
	'between'
	{ after(grammarAccess.getSequencePatternAccess().getBetweenKeyword_1_1_3_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_2__1__Impl
	rule__SequencePattern__Group_1_1_3_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getMinAssignment_1_1_3_2_1()); }
	(rule__SequencePattern__MinAssignment_1_1_3_2_1)
	{ after(grammarAccess.getSequencePatternAccess().getMinAssignment_1_1_3_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_2__2__Impl
	rule__SequencePattern__Group_1_1_3_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getAndKeyword_1_1_3_2_2()); }
	'and'
	{ after(grammarAccess.getSequencePatternAccess().getAndKeyword_1_1_3_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_2__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__SequencePattern__Group_1_1_3_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__Group_1_1_3_2__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getSequencePatternAccess().getMaxAssignment_1_1_3_2_3()); }
	(rule__SequencePattern__MaxAssignment_1_1_3_2_3)
	{ after(grammarAccess.getSequencePatternAccess().getMaxAssignment_1_1_3_2_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLQuantified__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0__0__Impl
	rule__LTLQuantified__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getAlternatives_0_0()); }
	(rule__LTLQuantified__Alternatives_0_0)
	{ after(grammarAccess.getLTLQuantifiedAccess().getAlternatives_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0__1__Impl
	rule__LTLQuantified__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getIndexAssignment_0_1()); }
	(rule__LTLQuantified__IndexAssignment_0_1)
	{ after(grammarAccess.getLTLQuantifiedAccess().getIndexAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0__2__Impl
	rule__LTLQuantified__Group_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getInKeyword_0_2()); }
	'in'
	{ after(grammarAccess.getLTLQuantifiedAccess().getInKeyword_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0__3__Impl
	rule__LTLQuantified__Group_0__4
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getTypeAssignment_0_3()); }
	(rule__LTLQuantified__TypeAssignment_0_3)
	{ after(grammarAccess.getLTLQuantifiedAccess().getTypeAssignment_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0__4__Impl
	rule__LTLQuantified__Group_0__5
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getFullStopKeyword_0_4()); }
	'.'
	{ after(grammarAccess.getLTLQuantifiedAccess().getFullStopKeyword_0_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getChildAssignment_0_5()); }
	(rule__LTLQuantified__ChildAssignment_0_5)
	{ after(grammarAccess.getLTLQuantifiedAccess().getChildAssignment_0_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLQuantified__Group_0_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0_0_0__0__Impl
	rule__LTLQuantified__Group_0_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getLTLAllAction_0_0_0_0()); }
	()
	{ after(grammarAccess.getLTLQuantifiedAccess().getLTLAllAction_0_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getAllKeyword_0_0_0_1()); }
	'all'
	{ after(grammarAccess.getLTLQuantifiedAccess().getAllKeyword_0_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLQuantified__Group_0_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0_0_1__0__Impl
	rule__LTLQuantified__Group_0_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getLTLExistsAction_0_0_1_0()); }
	()
	{ after(grammarAccess.getLTLQuantifiedAccess().getLTLExistsAction_0_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLQuantified__Group_0_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__Group_0_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLQuantifiedAccess().getExistsKeyword_0_0_1_1()); }
	'exists'
	{ after(grammarAccess.getLTLQuantifiedAccess().getExistsKeyword_0_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLDisjunction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLDisjunction__Group__0__Impl
	rule__LTLDisjunction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLDisjunctionAccess().getLTLImplicationParserRuleCall_0()); }
	ruleLTLImplication
	{ after(grammarAccess.getLTLDisjunctionAccess().getLTLImplicationParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLDisjunction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLDisjunctionAccess().getGroup_1()); }
	(rule__LTLDisjunction__Group_1__0)*
	{ after(grammarAccess.getLTLDisjunctionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLDisjunction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLDisjunction__Group_1__0__Impl
	rule__LTLDisjunction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLDisjunctionAccess().getLTLDisjunctionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getLTLDisjunctionAccess().getLTLDisjunctionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLDisjunction__Group_1__1__Impl
	rule__LTLDisjunction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLDisjunctionAccess().getOrKeyword_1_1()); }
	'or'
	{ after(grammarAccess.getLTLDisjunctionAccess().getOrKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLDisjunction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLDisjunctionAccess().getRightAssignment_1_2()); }
	(rule__LTLDisjunction__RightAssignment_1_2)
	{ after(grammarAccess.getLTLDisjunctionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLImplication__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLImplication__Group__0__Impl
	rule__LTLImplication__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLImplicationAccess().getLTLConjunctionParserRuleCall_0()); }
	ruleLTLConjunction
	{ after(grammarAccess.getLTLImplicationAccess().getLTLConjunctionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLImplication__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLImplicationAccess().getGroup_1()); }
	(rule__LTLImplication__Group_1__0)?
	{ after(grammarAccess.getLTLImplicationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLImplication__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLImplication__Group_1__0__Impl
	rule__LTLImplication__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLImplicationAccess().getLTLImplicationLeftAction_1_0()); }
	()
	{ after(grammarAccess.getLTLImplicationAccess().getLTLImplicationLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLImplication__Group_1__1__Impl
	rule__LTLImplication__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLImplicationAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
	'=>'
	{ after(grammarAccess.getLTLImplicationAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLImplication__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLImplicationAccess().getRightAssignment_1_2()); }
	(rule__LTLImplication__RightAssignment_1_2)
	{ after(grammarAccess.getLTLImplicationAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLConjunction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLConjunction__Group__0__Impl
	rule__LTLConjunction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLConjunctionAccess().getLTLBinaryParserRuleCall_0()); }
	ruleLTLBinary
	{ after(grammarAccess.getLTLConjunctionAccess().getLTLBinaryParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLConjunction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLConjunctionAccess().getGroup_1()); }
	(rule__LTLConjunction__Group_1__0)*
	{ after(grammarAccess.getLTLConjunctionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLConjunction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLConjunction__Group_1__0__Impl
	rule__LTLConjunction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLConjunctionAccess().getLTLConjunctionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getLTLConjunctionAccess().getLTLConjunctionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLConjunction__Group_1__1__Impl
	rule__LTLConjunction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLConjunctionAccess().getAndKeyword_1_1()); }
	'and'
	{ after(grammarAccess.getLTLConjunctionAccess().getAndKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLConjunction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLConjunctionAccess().getRightAssignment_1_2()); }
	(rule__LTLConjunction__RightAssignment_1_2)
	{ after(grammarAccess.getLTLConjunctionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLBinary__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLBinary__Group__0__Impl
	rule__LTLBinary__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLBinaryAccess().getLTLUnaryParserRuleCall_0()); }
	ruleLTLUnary
	{ after(grammarAccess.getLTLBinaryAccess().getLTLUnaryParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLBinary__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLBinaryAccess().getAlternatives_1()); }
	(rule__LTLBinary__Alternatives_1)?
	{ after(grammarAccess.getLTLBinaryAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLBinary__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLBinary__Group_1_0__0__Impl
	rule__LTLBinary__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLBinaryAccess().getLTLUntilLeftAction_1_0_0()); }
	()
	{ after(grammarAccess.getLTLBinaryAccess().getLTLUntilLeftAction_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLBinary__Group_1_0__1__Impl
	rule__LTLBinary__Group_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLBinaryAccess().getUntilKeyword_1_0_1()); }
	'until'
	{ after(grammarAccess.getLTLBinaryAccess().getUntilKeyword_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLBinary__Group_1_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLBinaryAccess().getRightAssignment_1_0_2()); }
	(rule__LTLBinary__RightAssignment_1_0_2)
	{ after(grammarAccess.getLTLBinaryAccess().getRightAssignment_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLBinary__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLBinary__Group_1_1__0__Impl
	rule__LTLBinary__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLBinaryAccess().getLTLReleaseLeftAction_1_1_0()); }
	()
	{ after(grammarAccess.getLTLBinaryAccess().getLTLReleaseLeftAction_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLBinary__Group_1_1__1__Impl
	rule__LTLBinary__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLBinaryAccess().getReleaseKeyword_1_1_1()); }
	'release'
	{ after(grammarAccess.getLTLBinaryAccess().getReleaseKeyword_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLBinary__Group_1_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLBinaryAccess().getRightAssignment_1_1_2()); }
	(rule__LTLBinary__RightAssignment_1_1_2)
	{ after(grammarAccess.getLTLBinaryAccess().getRightAssignment_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLUnary__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0__0__Impl
	rule__LTLUnary__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getAlternatives_0_0()); }
	(rule__LTLUnary__Alternatives_0_0)
	{ after(grammarAccess.getLTLUnaryAccess().getAlternatives_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getOperandAssignment_0_1()); }
	(rule__LTLUnary__OperandAssignment_0_1)
	{ after(grammarAccess.getLTLUnaryAccess().getOperandAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLUnary__Group_0_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0_0_0__0__Impl
	rule__LTLUnary__Group_0_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getLTLUnaryNegationAction_0_0_0_0()); }
	()
	{ after(grammarAccess.getLTLUnaryAccess().getLTLUnaryNegationAction_0_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getNotKeyword_0_0_0_1()); }
	'not'
	{ after(grammarAccess.getLTLUnaryAccess().getNotKeyword_0_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLUnary__Group_0_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0_0_1__0__Impl
	rule__LTLUnary__Group_0_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getLTLUnaryNextAction_0_0_1_0()); }
	()
	{ after(grammarAccess.getLTLUnaryAccess().getLTLUnaryNextAction_0_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getNextKeyword_0_0_1_1()); }
	'next'
	{ after(grammarAccess.getLTLUnaryAccess().getNextKeyword_0_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLUnary__Group_0_0_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0_0_2__0__Impl
	rule__LTLUnary__Group_0_0_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getLTLUnaryAlwaysAction_0_0_2_0()); }
	()
	{ after(grammarAccess.getLTLUnaryAccess().getLTLUnaryAlwaysAction_0_0_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0_0_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getLeftSquareBracketRightSquareBracketKeyword_0_0_2_1()); }
	'[]'
	{ after(grammarAccess.getLTLUnaryAccess().getLeftSquareBracketRightSquareBracketKeyword_0_0_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LTLUnary__Group_0_0_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0_0_3__0__Impl
	rule__LTLUnary__Group_0_0_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getLTLUnaryEventuallyAction_0_0_3_0()); }
	()
	{ after(grammarAccess.getLTLUnaryAccess().getLTLUnaryEventuallyAction_0_0_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LTLUnary__Group_0_0_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__Group_0_0_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLTLUnaryAccess().getLessThanSignGreaterThanSignKeyword_0_0_3_1()); }
	'<>'
	{ after(grammarAccess.getLTLUnaryAccess().getLessThanSignGreaterThanSignKeyword_0_0_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AtomicLTL__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicLTL__Group_0__0__Impl
	rule__AtomicLTL__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicLTLAccess().getLTLVariableAction_0_0()); }
	()
	{ after(grammarAccess.getAtomicLTLAccess().getLTLVariableAction_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicLTL__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicLTLAccess().getDeclarationAssignment_0_1()); }
	(rule__AtomicLTL__DeclarationAssignment_0_1)
	{ after(grammarAccess.getAtomicLTLAccess().getDeclarationAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AtomicLTL__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicLTL__Group_2__0__Impl
	rule__AtomicLTL__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicLTLAccess().getLeftParenthesisKeyword_2_0()); }
	'('
	{ after(grammarAccess.getAtomicLTLAccess().getLeftParenthesisKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicLTL__Group_2__1__Impl
	rule__AtomicLTL__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicLTLAccess().getLTLPropertyParserRuleCall_2_1()); }
	ruleLTLProperty
	{ after(grammarAccess.getAtomicLTLAccess().getLTLPropertyParserRuleCall_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Group_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicLTL__Group_2__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__Group_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicLTLAccess().getRightParenthesisKeyword_2_2()); }
	')'
	{ after(grammarAccess.getAtomicLTLAccess().getRightParenthesisKeyword_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__EnterStateEvent__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnterStateEvent__Group__0__Impl
	rule__EnterStateEvent__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnterStateEvent__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnterStateEventAccess().getEnterKeyword_0()); }
	'enter'
	{ after(grammarAccess.getEnterStateEventAccess().getEnterKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnterStateEvent__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnterStateEvent__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnterStateEvent__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnterStateEventAccess().getSubjectAssignment_1()); }
	(rule__EnterStateEvent__SubjectAssignment_1)
	{ after(grammarAccess.getEnterStateEventAccess().getSubjectAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LeaveStateEvent__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LeaveStateEvent__Group__0__Impl
	rule__LeaveStateEvent__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LeaveStateEvent__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLeaveStateEventAccess().getLeaveKeyword_0()); }
	'leave'
	{ after(grammarAccess.getLeaveStateEventAccess().getLeaveKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LeaveStateEvent__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LeaveStateEvent__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LeaveStateEvent__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLeaveStateEventAccess().getSubjectAssignment_1()); }
	(rule__LeaveStateEvent__SubjectAssignment_1)
	{ after(grammarAccess.getLeaveStateEventAccess().getSubjectAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObservableDisjunction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableDisjunction__Group__0__Impl
	rule__ObservableDisjunction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableDisjunctionAccess().getObservableImplicationParserRuleCall_0()); }
	ruleObservableImplication
	{ after(grammarAccess.getObservableDisjunctionAccess().getObservableImplicationParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableDisjunction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableDisjunctionAccess().getGroup_1()); }
	(rule__ObservableDisjunction__Group_1__0)*
	{ after(grammarAccess.getObservableDisjunctionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObservableDisjunction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableDisjunction__Group_1__0__Impl
	rule__ObservableDisjunction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableDisjunctionAccess().getObservableDisjunctionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getObservableDisjunctionAccess().getObservableDisjunctionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableDisjunction__Group_1__1__Impl
	rule__ObservableDisjunction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableDisjunctionAccess().getOrKeyword_1_1()); }
	'or'
	{ after(grammarAccess.getObservableDisjunctionAccess().getOrKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableDisjunction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableDisjunctionAccess().getRightAssignment_1_2()); }
	(rule__ObservableDisjunction__RightAssignment_1_2)
	{ after(grammarAccess.getObservableDisjunctionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObservableImplication__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableImplication__Group__0__Impl
	rule__ObservableImplication__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableImplicationAccess().getObservableConjunctionParserRuleCall_0()); }
	ruleObservableConjunction
	{ after(grammarAccess.getObservableImplicationAccess().getObservableConjunctionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableImplication__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableImplicationAccess().getGroup_1()); }
	(rule__ObservableImplication__Group_1__0)?
	{ after(grammarAccess.getObservableImplicationAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObservableImplication__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableImplication__Group_1__0__Impl
	rule__ObservableImplication__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableImplicationAccess().getObservableImplicationLeftAction_1_0()); }
	()
	{ after(grammarAccess.getObservableImplicationAccess().getObservableImplicationLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableImplication__Group_1__1__Impl
	rule__ObservableImplication__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableImplicationAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
	'=>'
	{ after(grammarAccess.getObservableImplicationAccess().getEqualsSignGreaterThanSignKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableImplication__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableImplicationAccess().getRightAssignment_1_2()); }
	(rule__ObservableImplication__RightAssignment_1_2)
	{ after(grammarAccess.getObservableImplicationAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObservableConjunction__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableConjunction__Group__0__Impl
	rule__ObservableConjunction__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableConjunctionAccess().getObservableNegationParserRuleCall_0()); }
	ruleObservableNegation
	{ after(grammarAccess.getObservableConjunctionAccess().getObservableNegationParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableConjunction__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableConjunctionAccess().getGroup_1()); }
	(rule__ObservableConjunction__Group_1__0)*
	{ after(grammarAccess.getObservableConjunctionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObservableConjunction__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableConjunction__Group_1__0__Impl
	rule__ObservableConjunction__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableConjunctionAccess().getObservableConjunctionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getObservableConjunctionAccess().getObservableConjunctionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableConjunction__Group_1__1__Impl
	rule__ObservableConjunction__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableConjunctionAccess().getAndKeyword_1_1()); }
	'and'
	{ after(grammarAccess.getObservableConjunctionAccess().getAndKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableConjunction__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableConjunctionAccess().getRightAssignment_1_2()); }
	(rule__ObservableConjunction__RightAssignment_1_2)
	{ after(grammarAccess.getObservableConjunctionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObservableNegation__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableNegation__Group_0__0__Impl
	rule__ObservableNegation__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableNegation__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableNegationAccess().getObservableNegationAction_0_0()); }
	()
	{ after(grammarAccess.getObservableNegationAccess().getObservableNegationAction_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableNegation__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableNegation__Group_0__1__Impl
	rule__ObservableNegation__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableNegation__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableNegationAccess().getNotKeyword_0_1()); }
	'not'
	{ after(grammarAccess.getObservableNegationAccess().getNotKeyword_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableNegation__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObservableNegation__Group_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableNegation__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObservableNegationAccess().getChildAssignment_0_2()); }
	(rule__ObservableNegation__ChildAssignment_0_2)
	{ after(grammarAccess.getObservableNegationAccess().getChildAssignment_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AtomicObservable__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicObservable__Group_0__0__Impl
	rule__AtomicObservable__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicObservable__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicObservableAccess().getLeftParenthesisKeyword_0_0()); }
	'('
	{ after(grammarAccess.getAtomicObservableAccess().getLeftParenthesisKeyword_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicObservable__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicObservable__Group_0__1__Impl
	rule__AtomicObservable__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicObservable__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicObservableAccess().getObservableParserRuleCall_0_1()); }
	ruleObservable
	{ after(grammarAccess.getAtomicObservableAccess().getObservableParserRuleCall_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicObservable__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicObservable__Group_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicObservable__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicObservableAccess().getRightParenthesisKeyword_0_2()); }
	')'
	{ after(grammarAccess.getAtomicObservableAccess().getRightParenthesisKeyword_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PathEvent__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PathEvent__Group__0__Impl
	rule__PathEvent__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PathEvent__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPathEventAccess().getPathAssignment_0()); }
	(rule__PathEvent__PathAssignment_0)
	{ after(grammarAccess.getPathEventAccess().getPathAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathEvent__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PathEvent__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PathEvent__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPathEventAccess().getItemAssignment_1()); }
	(rule__PathEvent__ItemAssignment_1)
	{ after(grammarAccess.getPathEventAccess().getItemAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Path__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Path__Group__0__Impl
	rule__Path__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Path__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPathAccess().getItemsAssignment_0()); }
	(rule__Path__ItemsAssignment_0)
	{ after(grammarAccess.getPathAccess().getItemsAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Path__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Path__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Path__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPathAccess().getSolidusKeyword_1()); }
	'/'
	{ after(grammarAccess.getPathAccess().getSolidusKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__StateSubject__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StateSubject__Group__0__Impl
	rule__StateSubject__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StateSubject__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStateSubjectAccess().getStateKeyword_0()); }
	'state'
	{ after(grammarAccess.getStateSubjectAccess().getStateKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__StateSubject__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StateSubject__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StateSubject__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStateSubjectAccess().getStateAssignment_1()); }
	(rule__StateSubject__StateAssignment_1)
	{ after(grammarAccess.getStateSubjectAccess().getStateAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ValueSubject__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ValueSubject__Group__0__Impl
	rule__ValueSubject__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ValueSubject__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getValueSubjectAccess().getValueKeyword_0()); }
	'value'
	{ after(grammarAccess.getValueSubjectAccess().getValueKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ValueSubject__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ValueSubject__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ValueSubject__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getValueSubjectAccess().getValueAssignment_1()); }
	(rule__ValueSubject__ValueAssignment_1)
	{ after(grammarAccess.getValueSubjectAccess().getValueAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TagSubject__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TagSubject__Group__0__Impl
	rule__TagSubject__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TagSubject__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTagSubjectAccess().getTagKeyword_0()); }
	'tag'
	{ after(grammarAccess.getTagSubjectAccess().getTagKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TagSubject__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TagSubject__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TagSubject__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTagSubjectAccess().getTagAssignment_1()); }
	(rule__TagSubject__TagAssignment_1)
	{ after(grammarAccess.getTagSubjectAccess().getTagAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__EventSubject__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EventSubject__Group__0__Impl
	rule__EventSubject__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EventSubject__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEventSubjectAccess().getEventKeyword_0()); }
	'event'
	{ after(grammarAccess.getEventSubjectAccess().getEventKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EventSubject__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EventSubject__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EventSubject__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEventSubjectAccess().getEventAssignment_1()); }
	(rule__EventSubject__EventAssignment_1)
	{ after(grammarAccess.getEventSubjectAccess().getEventAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Model__ImportsAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getModelAccess().getImportsImportDeclarationParserRuleCall_1_0()); }
		ruleImportDeclaration
		{ after(grammarAccess.getModelAccess().getImportsImportDeclarationParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__DeclarationsAssignment_2_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getModelAccess().getDeclarationsDeclarationParserRuleCall_2_0_0()); }
		ruleDeclaration
		{ after(grammarAccess.getModelAccess().getDeclarationsDeclarationParserRuleCall_2_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__RequirementsAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getModelAccess().getRequirementsRequirementParserRuleCall_2_1_0()); }
		ruleRequirement
		{ after(grammarAccess.getModelAccess().getRequirementsRequirementParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Model__RootAssignment_2_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getModelAccess().getRootRootParserRuleCall_2_2_0()); }
		ruleRoot
		{ after(grammarAccess.getModelAccess().getRootRootParserRuleCall_2_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__DeclarationAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRootAccess().getDeclarationRootDeclarationCrossReference_1_0()); }
		(
			{ before(grammarAccess.getRootAccess().getDeclarationRootDeclarationIDTerminalRuleCall_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getRootAccess().getDeclarationRootDeclarationIDTerminalRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getRootAccess().getDeclarationRootDeclarationCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__ObservedAssignment_2_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRootAccess().getObservedRootDeclarationCrossReference_2_1_0_0()); }
		(
			{ before(grammarAccess.getRootAccess().getObservedRootDeclarationIDTerminalRuleCall_2_1_0_0_1()); }
			RULE_ID
			{ after(grammarAccess.getRootAccess().getObservedRootDeclarationIDTerminalRuleCall_2_1_0_0_1()); }
		)
		{ after(grammarAccess.getRootAccess().getObservedRootDeclarationCrossReference_2_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Root__ObservedAssignment_2_1_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRootAccess().getObservedRootDeclarationCrossReference_2_1_1_1_0()); }
		(
			{ before(grammarAccess.getRootAccess().getObservedRootDeclarationIDTerminalRuleCall_2_1_1_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getRootAccess().getObservedRootDeclarationIDTerminalRuleCall_2_1_1_1_0_1()); }
		)
		{ after(grammarAccess.getRootAccess().getObservedRootDeclarationCrossReference_2_1_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ImportDeclaration__ImportURIAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getImportDeclarationAccess().getImportURISTRINGTerminalRuleCall_1_0()); }
		RULE_STRING
		{ after(grammarAccess.getImportDeclarationAccess().getImportURISTRINGTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getFunctionDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__ParametersAssignment_2_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDeclarationAccess().getParametersParametersDeclarationParserRuleCall_2_1_0_0()); }
		ruleParametersDeclaration
		{ after(grammarAccess.getFunctionDeclarationAccess().getParametersParametersDeclarationParserRuleCall_2_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__ParametersAssignment_2_1_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDeclarationAccess().getParametersParametersDeclarationParserRuleCall_2_1_1_1_0()); }
		ruleParametersDeclaration
		{ after(grammarAccess.getFunctionDeclarationAccess().getParametersParametersDeclarationParserRuleCall_2_1_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__TypeAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDeclarationAccess().getTypeTypeParserRuleCall_4_0()); }
		ruleType
		{ after(grammarAccess.getFunctionDeclarationAccess().getTypeTypeParserRuleCall_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__VariablesAssignment_6_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_6_1_0()); }
		ruleVariablesDeclaration
		{ after(grammarAccess.getFunctionDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_6_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__VariablesAssignment_6_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_6_2_1_0()); }
		ruleVariablesDeclaration
		{ after(grammarAccess.getFunctionDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_6_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDeclaration__StatementAssignment_7
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDeclarationAccess().getStatementStatementParserRuleCall_7_0()); }
		ruleStatement
		{ after(grammarAccess.getFunctionDeclarationAccess().getStatementStatementParserRuleCall_7_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypeDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getTypeDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeDeclaration__ValueAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypeDeclarationAccess().getValueTypeParserRuleCall_3_0()); }
		ruleType
		{ after(grammarAccess.getTypeDeclarationAccess().getValueTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getChannelDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelDeclaration__ValueAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelDeclarationAccess().getValueChannelTypeParserRuleCall_3_0()); }
		ruleChannelType
		{ after(grammarAccess.getChannelDeclarationAccess().getValueChannelTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__SizeAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelTypeAccess().getSizeExpressionParserRuleCall_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getChannelTypeAccess().getSizeExpressionParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__InAssignment_2_0_0_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelTypeAccess().getInInKeyword_2_0_0_0_0_0()); }
		(
			{ before(grammarAccess.getChannelTypeAccess().getInInKeyword_2_0_0_0_0_0()); }
			'in'
			{ after(grammarAccess.getChannelTypeAccess().getInInKeyword_2_0_0_0_0_0()); }
		)
		{ after(grammarAccess.getChannelTypeAccess().getInInKeyword_2_0_0_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__OutAssignment_2_0_0_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelTypeAccess().getOutOutKeyword_2_0_0_0_1_0()); }
		(
			{ before(grammarAccess.getChannelTypeAccess().getOutOutKeyword_2_0_0_0_1_0()); }
			'out'
			{ after(grammarAccess.getChannelTypeAccess().getOutOutKeyword_2_0_0_0_1_0()); }
		)
		{ after(grammarAccess.getChannelTypeAccess().getOutOutKeyword_2_0_0_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__OutAssignment_2_0_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelTypeAccess().getOutOutKeyword_2_0_0_1_0()); }
		(
			{ before(grammarAccess.getChannelTypeAccess().getOutOutKeyword_2_0_0_1_0()); }
			'out'
			{ after(grammarAccess.getChannelTypeAccess().getOutOutKeyword_2_0_0_1_0()); }
		)
		{ after(grammarAccess.getChannelTypeAccess().getOutOutKeyword_2_0_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ChannelType__TypeAssignment_2_0_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getChannelTypeAccess().getTypeTupleTypeParserRuleCall_2_0_1_0_0()); }
		ruleTupleType
		{ after(grammarAccess.getChannelTypeAccess().getTypeTupleTypeParserRuleCall_2_0_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TupleType__TypesAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTupleTypeAccess().getTypesTypeParserRuleCall_1_2_0()); }
		ruleType
		{ after(grammarAccess.getTupleTypeAccess().getTypesTypeParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeType__MinimumAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRangeTypeAccess().getMinimumExpressionParserRuleCall_0_0()); }
		ruleExpression
		{ after(grammarAccess.getRangeTypeAccess().getMinimumExpressionParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RangeType__MaximumAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRangeTypeAccess().getMaximumExpressionParserRuleCall_2_0()); }
		ruleExpression
		{ after(grammarAccess.getRangeTypeAccess().getMaximumExpressionParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__TagsAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnionTypeAccess().getTagsUnionTagsParserRuleCall_1_0()); }
		ruleUnionTags
		{ after(grammarAccess.getUnionTypeAccess().getTagsUnionTagsParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionType__TagsAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnionTypeAccess().getTagsUnionTagsParserRuleCall_2_1_0()); }
		ruleUnionTags
		{ after(grammarAccess.getUnionTypeAccess().getTagsUnionTagsParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__TagsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnionTagsAccess().getTagsUnionTagDeclarationParserRuleCall_0_0()); }
		ruleUnionTagDeclaration
		{ after(grammarAccess.getUnionTagsAccess().getTagsUnionTagDeclarationParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__TagsAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnionTagsAccess().getTagsUnionTagDeclarationParserRuleCall_1_1_0()); }
		ruleUnionTagDeclaration
		{ after(grammarAccess.getUnionTagsAccess().getTagsUnionTagDeclarationParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTags__TypeAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnionTagsAccess().getTypeTypeParserRuleCall_2_1_0()); }
		ruleType
		{ after(grammarAccess.getUnionTagsAccess().getTypeTypeParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnionTagDeclaration__NameAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnionTagDeclarationAccess().getNameIDTerminalRuleCall_0()); }
		RULE_ID
		{ after(grammarAccess.getUnionTagDeclarationAccess().getNameIDTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__FieldsAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRecordTypeAccess().getFieldsRecordFieldsParserRuleCall_1_0()); }
		ruleRecordFields
		{ after(grammarAccess.getRecordTypeAccess().getFieldsRecordFieldsParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordType__FieldsAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRecordTypeAccess().getFieldsRecordFieldsParserRuleCall_2_1_0()); }
		ruleRecordFields
		{ after(grammarAccess.getRecordTypeAccess().getFieldsRecordFieldsParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__FieldsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRecordFieldsAccess().getFieldsRecordFieldDeclarationParserRuleCall_0_0()); }
		ruleRecordFieldDeclaration
		{ after(grammarAccess.getRecordFieldsAccess().getFieldsRecordFieldDeclarationParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__FieldsAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRecordFieldsAccess().getFieldsRecordFieldDeclarationParserRuleCall_1_1_0()); }
		ruleRecordFieldDeclaration
		{ after(grammarAccess.getRecordFieldsAccess().getFieldsRecordFieldDeclarationParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFields__TypeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRecordFieldsAccess().getTypeTypeParserRuleCall_3_0()); }
		ruleType
		{ after(grammarAccess.getRecordFieldsAccess().getTypeTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordFieldDeclaration__NameAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRecordFieldDeclarationAccess().getNameIDTerminalRuleCall_0()); }
		RULE_ID
		{ after(grammarAccess.getRecordFieldDeclarationAccess().getNameIDTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__SizeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQueueTypeAccess().getSizeExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getQueueTypeAccess().getSizeExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueType__TypeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQueueTypeAccess().getTypeTypeParserRuleCall_3_0()); }
		ruleType
		{ after(grammarAccess.getQueueTypeAccess().getTypeTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__SizeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getArrayTypeAccess().getSizeExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getArrayTypeAccess().getSizeExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayType__TypeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getArrayTypeAccess().getTypeTypeParserRuleCall_3_0()); }
		ruleType
		{ after(grammarAccess.getArrayTypeAccess().getTypeTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ReferencedType__TypeAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getReferencedTypeAccess().getTypeTypeDeclarationUseCrossReference_0()); }
		(
			{ before(grammarAccess.getReferencedTypeAccess().getTypeTypeDeclarationUseIDTerminalRuleCall_0_1()); }
			RULE_ID
			{ after(grammarAccess.getReferencedTypeAccess().getTypeTypeDeclarationUseIDTerminalRuleCall_0_1()); }
		)
		{ after(grammarAccess.getReferencedTypeAccess().getTypeTypeDeclarationUseCrossReference_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConstantDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getConstantDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__TypeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConstantDeclarationAccess().getTypeTypeParserRuleCall_3_0()); }
		ruleType
		{ after(grammarAccess.getConstantDeclarationAccess().getTypeTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantDeclaration__ValueAssignment_5
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConstantDeclarationAccess().getValueExpressionParserRuleCall_5_0()); }
		ruleExpression
		{ after(grammarAccess.getConstantDeclarationAccess().getValueExpressionParserRuleCall_5_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getProcessDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__PortsAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getPortsPortsDeclarationParserRuleCall_2_1_0()); }
		rulePortsDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getPortsPortsDeclarationParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__PortsAssignment_2_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getPortsPortsDeclarationParserRuleCall_2_2_1_0()); }
		rulePortsDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getPortsPortsDeclarationParserRuleCall_2_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__ParametersAssignment_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getParametersParametersDeclarationParserRuleCall_3_1_0()); }
		ruleParametersDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getParametersParametersDeclarationParserRuleCall_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__ParametersAssignment_3_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getParametersParametersDeclarationParserRuleCall_3_2_1_0()); }
		ruleParametersDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getParametersParametersDeclarationParserRuleCall_3_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__LocalPortsAssignment_5_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getLocalPortsPortsDeclarationParserRuleCall_5_1_0()); }
		rulePortsDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getLocalPortsPortsDeclarationParserRuleCall_5_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__LocalPortsAssignment_5_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getLocalPortsPortsDeclarationParserRuleCall_5_2_1_0()); }
		rulePortsDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getLocalPortsPortsDeclarationParserRuleCall_5_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__PrioritiesAssignment_6_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getPrioritiesPriorityDeclarationParserRuleCall_6_1_0()); }
		rulePriorityDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getPrioritiesPriorityDeclarationParserRuleCall_6_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__PrioritiesAssignment_6_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getPrioritiesPriorityDeclarationParserRuleCall_6_2_1_0()); }
		rulePriorityDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getPrioritiesPriorityDeclarationParserRuleCall_6_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__StatesAssignment_8
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getStatesStateDeclarationParserRuleCall_8_0()); }
		ruleStateDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getStatesStateDeclarationParserRuleCall_8_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__StatesAssignment_9_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getStatesStateDeclarationParserRuleCall_9_1_0()); }
		ruleStateDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getStatesStateDeclarationParserRuleCall_9_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__VariablesAssignment_10_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_10_1_0()); }
		ruleVariablesDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_10_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__VariablesAssignment_10_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_10_2_1_0()); }
		ruleVariablesDeclaration
		{ after(grammarAccess.getProcessDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_10_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__PreludeAssignment_11_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getPreludeStatementSequenceParserRuleCall_11_1_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getProcessDeclarationAccess().getPreludeStatementSequenceParserRuleCall_11_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ProcessDeclaration__TransitionsAssignment_12
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProcessDeclarationAccess().getTransitionsTransitionParserRuleCall_12_0()); }
		ruleTransition
		{ after(grammarAccess.getProcessDeclarationAccess().getTransitionsTransitionParserRuleCall_12_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__StateDeclaration__NameAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStateDeclarationAccess().getNameIDTerminalRuleCall_0()); }
		RULE_ID
		{ after(grammarAccess.getStateDeclarationAccess().getNameIDTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionSource__OriginAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTransitionSourceAccess().getOriginStateDeclarationCrossReference_1_0()); }
		(
			{ before(grammarAccess.getTransitionSourceAccess().getOriginStateDeclarationIDTerminalRuleCall_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getTransitionSourceAccess().getOriginStateDeclarationIDTerminalRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getTransitionSourceAccess().getOriginStateDeclarationCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Transition__SourceAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTransitionAccess().getSourceTransitionSourceParserRuleCall_0_0()); }
		ruleTransitionSource
		{ after(grammarAccess.getTransitionAccess().getSourceTransitionSourceParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Transition__ActionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTransitionAccess().getActionStatementSequenceParserRuleCall_1_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getTransitionAccess().getActionStatementSequenceParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getComponentDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__PortsAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getPortsPortsDeclarationParserRuleCall_2_1_0()); }
		rulePortsDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getPortsPortsDeclarationParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__PortsAssignment_2_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getPortsPortsDeclarationParserRuleCall_2_2_1_0()); }
		rulePortsDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getPortsPortsDeclarationParserRuleCall_2_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__ParametersAssignment_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getParametersParametersDeclarationParserRuleCall_3_1_0()); }
		ruleParametersDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getParametersParametersDeclarationParserRuleCall_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__ParametersAssignment_3_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getParametersParametersDeclarationParserRuleCall_3_2_1_0()); }
		ruleParametersDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getParametersParametersDeclarationParserRuleCall_3_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__VariablesAssignment_5_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_5_1_0()); }
		ruleVariablesDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_5_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__VariablesAssignment_5_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_5_2_1_0()); }
		ruleVariablesDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getVariablesVariablesDeclarationParserRuleCall_5_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__LocalPortsAssignment_6_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getLocalPortsLocalPortsDeclarationParserRuleCall_6_1_0()); }
		ruleLocalPortsDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getLocalPortsLocalPortsDeclarationParserRuleCall_6_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__LocalPortsAssignment_6_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getLocalPortsLocalPortsDeclarationParserRuleCall_6_2_1_0()); }
		ruleLocalPortsDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getLocalPortsLocalPortsDeclarationParserRuleCall_6_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__PrioritiesAssignment_7_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getPrioritiesPriorityDeclarationParserRuleCall_7_1_0()); }
		rulePriorityDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getPrioritiesPriorityDeclarationParserRuleCall_7_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__PrioritiesAssignment_7_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getPrioritiesPriorityDeclarationParserRuleCall_7_2_1_0()); }
		rulePriorityDeclaration
		{ after(grammarAccess.getComponentDeclarationAccess().getPrioritiesPriorityDeclarationParserRuleCall_7_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__PreludeAssignment_8_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getPreludeStatementSequenceParserRuleCall_8_1_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getComponentDeclarationAccess().getPreludeStatementSequenceParserRuleCall_8_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentDeclaration__BodyAssignment_9
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentDeclarationAccess().getBodyCompositionParserRuleCall_9_0()); }
		ruleComposition
		{ after(grammarAccess.getComponentDeclarationAccess().getBodyCompositionParserRuleCall_9_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__PortsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPortsDeclarationAccess().getPortsPortDeclarationParserRuleCall_0_0()); }
		rulePortDeclaration
		{ after(grammarAccess.getPortsDeclarationAccess().getPortsPortDeclarationParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__PortsAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPortsDeclarationAccess().getPortsPortDeclarationParserRuleCall_1_1_0()); }
		rulePortDeclaration
		{ after(grammarAccess.getPortsDeclarationAccess().getPortsPortDeclarationParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortsDeclaration__TypeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPortsDeclarationAccess().getTypeChannelTypeParserRuleCall_3_0()); }
		ruleChannelType
		{ after(grammarAccess.getPortsDeclarationAccess().getTypeChannelTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortDeclaration__NameAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPortDeclarationAccess().getNameIDTerminalRuleCall_0()); }
		RULE_ID
		{ after(grammarAccess.getPortDeclarationAccess().getNameIDTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__PortsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLocalPortsDeclarationAccess().getPortsPortDeclarationParserRuleCall_0_0()); }
		rulePortDeclaration
		{ after(grammarAccess.getLocalPortsDeclarationAccess().getPortsPortDeclarationParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__PortsAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLocalPortsDeclarationAccess().getPortsPortDeclarationParserRuleCall_1_1_0()); }
		rulePortDeclaration
		{ after(grammarAccess.getLocalPortsDeclarationAccess().getPortsPortDeclarationParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__TypeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLocalPortsDeclarationAccess().getTypeChannelTypeParserRuleCall_3_0()); }
		ruleChannelType
		{ after(grammarAccess.getLocalPortsDeclarationAccess().getTypeChannelTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__LeftAssignment_4_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLocalPortsDeclarationAccess().getLeftLowerBoundParserRuleCall_4_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getLocalPortsDeclarationAccess().getLeftLowerBoundParserRuleCall_4_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LocalPortsDeclaration__RightAssignment_4_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLocalPortsDeclarationAccess().getRightUpperBoundParserRuleCall_4_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getLocalPortsDeclarationAccess().getRightUpperBoundParserRuleCall_4_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__ParametersAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParametersDeclarationAccess().getParametersParameterDeclarationParserRuleCall_0_0()); }
		ruleParameterDeclaration
		{ after(grammarAccess.getParametersDeclarationAccess().getParametersParameterDeclarationParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__ParametersAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParametersDeclarationAccess().getParametersParameterDeclarationParserRuleCall_1_1_0()); }
		ruleParameterDeclaration
		{ after(grammarAccess.getParametersDeclarationAccess().getParametersParameterDeclarationParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__ReadAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParametersDeclarationAccess().getReadReadKeyword_3_0()); }
		(
			{ before(grammarAccess.getParametersDeclarationAccess().getReadReadKeyword_3_0()); }
			'read'
			{ after(grammarAccess.getParametersDeclarationAccess().getReadReadKeyword_3_0()); }
		)
		{ after(grammarAccess.getParametersDeclarationAccess().getReadReadKeyword_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__WriteAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParametersDeclarationAccess().getWriteWriteKeyword_4_0()); }
		(
			{ before(grammarAccess.getParametersDeclarationAccess().getWriteWriteKeyword_4_0()); }
			'write'
			{ after(grammarAccess.getParametersDeclarationAccess().getWriteWriteKeyword_4_0()); }
		)
		{ after(grammarAccess.getParametersDeclarationAccess().getWriteWriteKeyword_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParametersDeclaration__TypeAssignment_5
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParametersDeclarationAccess().getTypeTypeParserRuleCall_5_0()); }
		ruleType
		{ after(grammarAccess.getParametersDeclarationAccess().getTypeTypeParserRuleCall_5_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__ReferenceAssignment_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParameterDeclarationAccess().getReferenceAmpersandKeyword_0_0_0()); }
		(
			{ before(grammarAccess.getParameterDeclarationAccess().getReferenceAmpersandKeyword_0_0_0()); }
			'&'
			{ after(grammarAccess.getParameterDeclarationAccess().getReferenceAmpersandKeyword_0_0_0()); }
		)
		{ after(grammarAccess.getParameterDeclarationAccess().getReferenceAmpersandKeyword_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__ArrayAssignment_0_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParameterDeclarationAccess().getArrayLeftSquareBracketKeyword_0_1_0_0()); }
		(
			{ before(grammarAccess.getParameterDeclarationAccess().getArrayLeftSquareBracketKeyword_0_1_0_0()); }
			'['
			{ after(grammarAccess.getParameterDeclarationAccess().getArrayLeftSquareBracketKeyword_0_1_0_0()); }
		)
		{ after(grammarAccess.getParameterDeclarationAccess().getArrayLeftSquareBracketKeyword_0_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__SizeAssignment_0_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParameterDeclarationAccess().getSizeExpressionParserRuleCall_0_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getParameterDeclarationAccess().getSizeExpressionParserRuleCall_0_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ParameterDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getParameterDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getParameterDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__VariablesAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariablesDeclarationAccess().getVariablesVariableDeclarationParserRuleCall_0_0()); }
		ruleVariableDeclaration
		{ after(grammarAccess.getVariablesDeclarationAccess().getVariablesVariableDeclarationParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__VariablesAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariablesDeclarationAccess().getVariablesVariableDeclarationParserRuleCall_1_1_0()); }
		ruleVariableDeclaration
		{ after(grammarAccess.getVariablesDeclarationAccess().getVariablesVariableDeclarationParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__TypeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariablesDeclarationAccess().getTypeTypeParserRuleCall_3_0()); }
		ruleType
		{ after(grammarAccess.getVariablesDeclarationAccess().getTypeTypeParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariablesDeclaration__ValueAssignment_4_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariablesDeclarationAccess().getValueExpressionParserRuleCall_4_1_0()); }
		ruleExpression
		{ after(grammarAccess.getVariablesDeclarationAccess().getValueExpressionParserRuleCall_4_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableDeclaration__NameAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableDeclarationAccess().getNameIDTerminalRuleCall_0()); }
		RULE_ID
		{ after(grammarAccess.getVariableDeclarationAccess().getNameIDTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityDeclaration__GroupsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPriorityDeclarationAccess().getGroupsPriorityGroupParserRuleCall_0_0()); }
		rulePriorityGroup
		{ after(grammarAccess.getPriorityDeclarationAccess().getGroupsPriorityGroupParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityDeclaration__GroupsAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPriorityDeclarationAccess().getGroupsPriorityGroupParserRuleCall_1_1_0()); }
		rulePriorityGroup
		{ after(grammarAccess.getPriorityDeclarationAccess().getGroupsPriorityGroupParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityGroup__PortsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPriorityGroupAccess().getPortsPortDeclarationCrossReference_0_0()); }
		(
			{ before(grammarAccess.getPriorityGroupAccess().getPortsPortDeclarationIDTerminalRuleCall_0_0_1()); }
			RULE_ID
			{ after(grammarAccess.getPriorityGroupAccess().getPortsPortDeclarationIDTerminalRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getPriorityGroupAccess().getPortsPortDeclarationCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PriorityGroup__PortsAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPriorityGroupAccess().getPortsPortDeclarationCrossReference_1_1_0()); }
		(
			{ before(grammarAccess.getPriorityGroupAccess().getPortsPortDeclarationIDTerminalRuleCall_1_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getPriorityGroupAccess().getPortsPortDeclarationIDTerminalRuleCall_1_1_0_1()); }
		)
		{ after(grammarAccess.getPriorityGroupAccess().getPortsPortDeclarationCrossReference_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnlessStatement__FollowersAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnlessStatementAccess().getFollowersStatementChoiceParserRuleCall_1_2_0()); }
		ruleStatementChoice
		{ after(grammarAccess.getUnlessStatementAccess().getFollowersStatementChoiceParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementChoice__ChoicesAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStatementChoiceAccess().getChoicesStatementSequenceParserRuleCall_1_2_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getStatementChoiceAccess().getChoicesStatementSequenceParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__StatementSequence__StatementsAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStatementSequenceAccess().getStatementsStatementParserRuleCall_1_2_0()); }
		ruleStatement
		{ after(grammarAccess.getStatementSequenceAccess().getStatementsStatementParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BlockStatement__BodyAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBlockStatementAccess().getBodyStatementSequenceParserRuleCall_1_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getBlockStatementAccess().getBodyStatementSequenceParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ReturnStatement__ExpressionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getReturnStatementAccess().getExpressionExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TaggedStatement__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTaggedStatementAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getTaggedStatementAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__PatternsAssignment_1_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_0_2_0()); }
		rulePattern
		{ after(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__PatternsAssignment_1_0_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_0_3_1_0()); }
		rulePattern
		{ after(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_0_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ValuesAssignment_1_0_5
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_0_5_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_0_5_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ValuesAssignment_1_0_6_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_0_6_1_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_0_6_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ValuesAssignment_1_1_2_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_1_2_0_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_1_2_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ValuesAssignment_1_1_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_1_2_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_1_2_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__PatternsAssignment_1_2_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_2_2_0()); }
		rulePattern
		{ after(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_2_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__PatternsAssignment_1_2_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_2_3_1_0()); }
		rulePattern
		{ after(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_2_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ExpAssignment_1_2_6_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getExpExpressionParserRuleCall_1_2_6_1_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getExpExpressionParserRuleCall_1_2_6_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ExpAssignment_1_3_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getExpExpressionParserRuleCall_1_3_3_1_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getExpExpressionParserRuleCall_1_3_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ValuesAssignment_1_4_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_4_2_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_4_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ValuesAssignment_1_4_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_4_3_1_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getValuesExpressionParserRuleCall_1_4_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__PatternsAssignment_1_5_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_5_2_0()); }
		rulePattern
		{ after(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_5_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__PatternsAssignment_1_5_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_5_3_1_0()); }
		rulePattern
		{ after(grammarAccess.getPatternStatementAccess().getPatternsPatternParserRuleCall_1_5_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PatternStatement__ExpAssignment_1_5_4_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPatternStatementAccess().getExpExpressionParserRuleCall_1_5_4_1_0()); }
		ruleExpression
		{ after(grammarAccess.getPatternStatementAccess().getExpExpressionParserRuleCall_1_5_4_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConstantPattern__ValueAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConstantPatternAccess().getValueLiteralExpressionParserRuleCall_0()); }
		ruleLiteralExpression
		{ after(grammarAccess.getConstantPatternAccess().getValueLiteralExpressionParserRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerPattern__NegativeAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIntegerPatternAccess().getNegativeHyphenMinusKeyword_0_1_0()); }
		(
			{ before(grammarAccess.getIntegerPatternAccess().getNegativeHyphenMinusKeyword_0_1_0()); }
			'-'
			{ after(grammarAccess.getIntegerPatternAccess().getNegativeHyphenMinusKeyword_0_1_0()); }
		)
		{ after(grammarAccess.getIntegerPatternAccess().getNegativeHyphenMinusKeyword_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IntegerPattern__ValueAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIntegerPatternAccess().getValueINTTerminalRuleCall_1_0()); }
		RULE_INT
		{ after(grammarAccess.getIntegerPatternAccess().getValueINTTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__DeclarationAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseCrossReference_0_1_0()); }
		(
			{ before(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseIDTerminalRuleCall_0_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseIDTerminalRuleCall_0_1_0_1()); }
		)
		{ after(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseCrossReference_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__ParametersAssignment_0_3_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getParametersPatternParserRuleCall_0_3_0_0()); }
		rulePattern
		{ after(grammarAccess.getIdentifierPatternAccess().getParametersPatternParserRuleCall_0_3_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__ParametersAssignment_0_3_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getParametersPatternParserRuleCall_0_3_1_1_0()); }
		rulePattern
		{ after(grammarAccess.getIdentifierPatternAccess().getParametersPatternParserRuleCall_0_3_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__DeclarationAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseCrossReference_1_0_0()); }
		(
			{ before(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseIDTerminalRuleCall_1_0_0_1()); }
			RULE_ID
			{ after(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseIDTerminalRuleCall_1_0_0_1()); }
		)
		{ after(grammarAccess.getIdentifierPatternAccess().getDeclarationPatternDeclarationUseCrossReference_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__IndexAssignment_1_1_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getIndexExpressionParserRuleCall_1_1_0_2_0()); }
		ruleExpression
		{ after(grammarAccess.getIdentifierPatternAccess().getIndexExpressionParserRuleCall_1_1_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierPattern__FieldAssignment_1_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierPatternAccess().getFieldRecordFieldDeclarationCrossReference_1_1_1_2_0()); }
		(
			{ before(grammarAccess.getIdentifierPatternAccess().getFieldRecordFieldDeclarationIDTerminalRuleCall_1_1_1_2_0_1()); }
			RULE_ID
			{ after(grammarAccess.getIdentifierPatternAccess().getFieldRecordFieldDeclarationIDTerminalRuleCall_1_1_1_2_0_1()); }
		)
		{ after(grammarAccess.getIdentifierPatternAccess().getFieldRecordFieldDeclarationCrossReference_1_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__ConditionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalStatementAccess().getConditionExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getConditionalStatementAccess().getConditionExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__ThenAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalStatementAccess().getThenStatementSequenceParserRuleCall_3_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getConditionalStatementAccess().getThenStatementSequenceParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__ElseifAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalStatementAccess().getElseifExtendedConditionalStatementParserRuleCall_4_0()); }
		ruleExtendedConditionalStatement
		{ after(grammarAccess.getConditionalStatementAccess().getElseifExtendedConditionalStatementParserRuleCall_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalStatement__ElseAssignment_5_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalStatementAccess().getElseStatementSequenceParserRuleCall_5_1_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getConditionalStatementAccess().getElseStatementSequenceParserRuleCall_5_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__ConditionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExtendedConditionalStatementAccess().getConditionExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getExtendedConditionalStatementAccess().getConditionExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExtendedConditionalStatement__ThenAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExtendedConditionalStatementAccess().getThenStatementSequenceParserRuleCall_3_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getExtendedConditionalStatementAccess().getThenStatementSequenceParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__BodyAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSelectStatementAccess().getBodyUnlessStatementParserRuleCall_1_0()); }
		ruleUnlessStatement
		{ after(grammarAccess.getSelectStatementAccess().getBodyUnlessStatementParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__IndexAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSelectStatementAccess().getIndexVariableDeclarationParserRuleCall_2_1_0()); }
		ruleVariableDeclaration
		{ after(grammarAccess.getSelectStatementAccess().getIndexVariableDeclarationParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SelectStatement__TypeAssignment_2_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSelectStatementAccess().getTypeRangeTypeParserRuleCall_2_3_0()); }
		ruleRangeType
		{ after(grammarAccess.getSelectStatementAccess().getTypeRangeTypeParserRuleCall_2_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__ConditionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getWhileStatementAccess().getConditionExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__WhileStatement__BodyAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getWhileStatementAccess().getBodyStatementSequenceParserRuleCall_3_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getWhileStatementAccess().getBodyStatementSequenceParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__VariableAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getForeachStatementAccess().getVariableVariableDeclarationParserRuleCall_1_0()); }
		ruleVariableDeclaration
		{ after(grammarAccess.getForeachStatementAccess().getVariableVariableDeclarationParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ForeachStatement__BodyAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getForeachStatementAccess().getBodyStatementSequenceParserRuleCall_3_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getForeachStatementAccess().getBodyStatementSequenceParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ToStatement__StateAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getToStatementAccess().getStateStateDeclarationCrossReference_1_0()); }
		(
			{ before(grammarAccess.getToStatementAccess().getStateStateDeclarationIDTerminalRuleCall_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getToStatementAccess().getStateStateDeclarationIDTerminalRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getToStatementAccess().getStateStateDeclarationCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__ValueAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCaseStatementAccess().getValueExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getCaseStatementAccess().getValueExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__PatternAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCaseStatementAccess().getPatternPatternParserRuleCall_3_0()); }
		rulePattern
		{ after(grammarAccess.getCaseStatementAccess().getPatternPatternParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__BodyAssignment_5
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCaseStatementAccess().getBodyStatementSequenceParserRuleCall_5_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getCaseStatementAccess().getBodyStatementSequenceParserRuleCall_5_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__PatternAssignment_6_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCaseStatementAccess().getPatternPatternParserRuleCall_6_1_0()); }
		rulePattern
		{ after(grammarAccess.getCaseStatementAccess().getPatternPatternParserRuleCall_6_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CaseStatement__BodyAssignment_6_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCaseStatementAccess().getBodyStatementSequenceParserRuleCall_6_3_0()); }
		ruleStatementSequence
		{ after(grammarAccess.getCaseStatementAccess().getBodyStatementSequenceParserRuleCall_6_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__OnStatement__ConditionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getOnStatementAccess().getConditionExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getOnStatementAccess().getConditionExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__LeftAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getWaitStatementAccess().getLeftLowerBoundParserRuleCall_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getWaitStatementAccess().getLeftLowerBoundParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__WaitStatement__RightAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getWaitStatementAccess().getRightUpperBoundParserRuleCall_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getWaitStatementAccess().getRightUpperBoundParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__GlobalAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCompositionAccess().getGlobalPortSetParserRuleCall_1_0_0()); }
		rulePortSet
		{ after(grammarAccess.getCompositionAccess().getGlobalPortSetParserRuleCall_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__BlocksAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCompositionAccess().getBlocksBlockParserRuleCall_2_0()); }
		ruleBlock
		{ after(grammarAccess.getCompositionAccess().getBlocksBlockParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Composition__BlocksAssignment_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCompositionAccess().getBlocksBlockParserRuleCall_3_1_0()); }
		ruleBlock
		{ after(grammarAccess.getCompositionAccess().getBlocksBlockParserRuleCall_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__LocalAssignment_0_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCompositeBlockAccess().getLocalPortSetParserRuleCall_0_0_0_0()); }
		rulePortSet
		{ after(grammarAccess.getCompositeBlockAccess().getLocalPortSetParserRuleCall_0_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CompositeBlock__CompositionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCompositeBlockAccess().getCompositionCompositionParserRuleCall_1_0()); }
		ruleComposition
		{ after(grammarAccess.getCompositeBlockAccess().getCompositionCompositionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__LocalAssignment_0_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getInstanceDeclarationAccess().getLocalPortSetParserRuleCall_0_0_0_0()); }
		rulePortSet
		{ after(grammarAccess.getInstanceDeclarationAccess().getLocalPortSetParserRuleCall_0_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__InstanceDeclaration__InstanceAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getInstanceDeclarationAccess().getInstanceComponentInstanceParserRuleCall_1_0()); }
		ruleComponentInstance
		{ after(grammarAccess.getInstanceDeclarationAccess().getInstanceComponentInstanceParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__AllPortsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPortSetAccess().getAllPortsAsteriskKeyword_0_0()); }
		(
			{ before(grammarAccess.getPortSetAccess().getAllPortsAsteriskKeyword_0_0()); }
			'*'
			{ after(grammarAccess.getPortSetAccess().getAllPortsAsteriskKeyword_0_0()); }
		)
		{ after(grammarAccess.getPortSetAccess().getAllPortsAsteriskKeyword_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__PortsAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPortSetAccess().getPortsExpressionParserRuleCall_1_0_0()); }
		ruleExpression
		{ after(grammarAccess.getPortSetAccess().getPortsExpressionParserRuleCall_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PortSet__PortsAssignment_1_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPortSetAccess().getPortsExpressionParserRuleCall_1_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getPortSetAccess().getPortsExpressionParserRuleCall_1_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__ComponentAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentInstanceAccess().getComponentParameterizedDeclarationCrossReference_0_0()); }
		(
			{ before(grammarAccess.getComponentInstanceAccess().getComponentParameterizedDeclarationIDTerminalRuleCall_0_0_1()); }
			RULE_ID
			{ after(grammarAccess.getComponentInstanceAccess().getComponentParameterizedDeclarationIDTerminalRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getComponentInstanceAccess().getComponentParameterizedDeclarationCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__PortsAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentInstanceAccess().getPortsExpressionParserRuleCall_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getComponentInstanceAccess().getPortsExpressionParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__PortsAssignment_1_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentInstanceAccess().getPortsExpressionParserRuleCall_1_2_1_0()); }
		ruleExpression
		{ after(grammarAccess.getComponentInstanceAccess().getPortsExpressionParserRuleCall_1_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__ParametersAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentInstanceAccess().getParametersExpressionParserRuleCall_2_1_0()); }
		ruleExpression
		{ after(grammarAccess.getComponentInstanceAccess().getParametersExpressionParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComponentInstance__ParametersAssignment_2_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComponentInstanceAccess().getParametersExpressionParserRuleCall_2_2_1_0()); }
		ruleExpression
		{ after(grammarAccess.getComponentInstanceAccess().getParametersExpressionParserRuleCall_2_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__IndexAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getIndexVariableDeclarationParserRuleCall_0_1_0()); }
		ruleVariableDeclaration
		{ after(grammarAccess.getQuantifiedExpressionAccess().getIndexVariableDeclarationParserRuleCall_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__TypeAssignment_0_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getTypeRangeTypeParserRuleCall_0_2_1_0()); }
		ruleRangeType
		{ after(grammarAccess.getQuantifiedExpressionAccess().getTypeRangeTypeParserRuleCall_0_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedExpression__ChildAssignment_0_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedExpressionAccess().getChildQuantifiedExpressionParserRuleCall_0_4_0()); }
		ruleQuantifiedExpression
		{ after(grammarAccess.getQuantifiedExpressionAccess().getChildQuantifiedExpressionParserRuleCall_0_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__ThenAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalAccess().getThenDisjunctionParserRuleCall_1_2_0()); }
		ruleDisjunction
		{ after(grammarAccess.getConditionalAccess().getThenDisjunctionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conditional__ElseAssignment_1_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalAccess().getElseDisjunctionParserRuleCall_1_4_0()); }
		ruleDisjunction
		{ after(grammarAccess.getConditionalAccess().getElseDisjunctionParserRuleCall_1_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Disjunction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDisjunctionAccess().getRightImplicationParserRuleCall_1_2_0()); }
		ruleImplication
		{ after(grammarAccess.getDisjunctionAccess().getRightImplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Implication__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getImplicationAccess().getRightImplicationParserRuleCall_1_2_0()); }
		ruleImplication
		{ after(grammarAccess.getImplicationAccess().getRightImplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Conjunction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConjunctionAccess().getRightComparisonParserRuleCall_1_2_0()); }
		ruleComparison
		{ after(grammarAccess.getConjunctionAccess().getRightComparisonParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Comparison__RightAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComparisonAccess().getRightAdditionParserRuleCall_1_1_0()); }
		ruleAddition
		{ after(grammarAccess.getComparisonAccess().getRightAdditionParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Addition__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAdditionAccess().getRightSubstractionParserRuleCall_1_2_0()); }
		ruleSubstraction
		{ after(grammarAccess.getAdditionAccess().getRightSubstractionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Substraction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSubstractionAccess().getRightMultiplicationParserRuleCall_1_2_0()); }
		ruleMultiplication
		{ after(grammarAccess.getSubstractionAccess().getRightMultiplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplication__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMultiplicationAccess().getRightDivisionParserRuleCall_1_2_0()); }
		ruleDivision
		{ after(grammarAccess.getMultiplicationAccess().getRightDivisionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Division__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDivisionAccess().getRightModuloParserRuleCall_1_2_0()); }
		ruleModulo
		{ after(grammarAccess.getDivisionAccess().getRightModuloParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Modulo__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getModuloAccess().getRightUnaryExpressionParserRuleCall_1_2_0()); }
		ruleUnaryExpression
		{ after(grammarAccess.getModuloAccess().getRightUnaryExpressionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__ChildAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0()); }
		ruleUnaryExpression
		{ after(grammarAccess.getUnaryExpressionAccess().getChildUnaryExpressionParserRuleCall_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Projection__FieldAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProjectionAccess().getFieldAtomicExpressionParserRuleCall_1_2_0()); }
		ruleAtomicExpression
		{ after(grammarAccess.getProjectionAccess().getFieldAtomicExpressionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ReferenceExpression__DeclarationAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getReferenceExpressionAccess().getDeclarationReferenceDeclarationUseCrossReference_1_0()); }
		(
			{ before(grammarAccess.getReferenceExpressionAccess().getDeclarationReferenceDeclarationUseIDTerminalRuleCall_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getReferenceExpressionAccess().getDeclarationReferenceDeclarationUseIDTerminalRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getReferenceExpressionAccess().getDeclarationReferenceDeclarationUseCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__DeclarationAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseCrossReference_0_1_0()); }
		(
			{ before(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseIDTerminalRuleCall_0_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseIDTerminalRuleCall_0_1_0_1()); }
		)
		{ after(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseCrossReference_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__ParametersAssignment_0_3_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getParametersExpressionParserRuleCall_0_3_0_0()); }
		ruleExpression
		{ after(grammarAccess.getIdentifierExpressionAccess().getParametersExpressionParserRuleCall_0_3_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__ParametersAssignment_0_3_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getParametersExpressionParserRuleCall_0_3_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getIdentifierExpressionAccess().getParametersExpressionParserRuleCall_0_3_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__DeclarationAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseCrossReference_1_0_0()); }
		(
			{ before(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseIDTerminalRuleCall_1_0_0_1()); }
			RULE_ID
			{ after(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseIDTerminalRuleCall_1_0_0_1()); }
		)
		{ after(grammarAccess.getIdentifierExpressionAccess().getDeclarationExpressionDeclarationUseCrossReference_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__IndexesAssignment_1_1_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getIndexesExpressionParserRuleCall_1_1_0_2_0()); }
		ruleExpression
		{ after(grammarAccess.getIdentifierExpressionAccess().getIndexesExpressionParserRuleCall_1_1_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__IndexesAssignment_1_1_0_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getIndexesExpressionParserRuleCall_1_1_0_3_1_0()); }
		ruleExpression
		{ after(grammarAccess.getIdentifierExpressionAccess().getIndexesExpressionParserRuleCall_1_1_0_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IdentifierExpression__FieldAssignment_1_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIdentifierExpressionAccess().getFieldRecordFieldDeclarationCrossReference_1_1_1_2_0()); }
		(
			{ before(grammarAccess.getIdentifierExpressionAccess().getFieldRecordFieldDeclarationIDTerminalRuleCall_1_1_1_2_0_1()); }
			RULE_ID
			{ after(grammarAccess.getIdentifierExpressionAccess().getFieldRecordFieldDeclarationIDTerminalRuleCall_1_1_1_2_0_1()); }
		)
		{ after(grammarAccess.getIdentifierExpressionAccess().getFieldRecordFieldDeclarationCrossReference_1_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__FieldsAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRecordExpressionAccess().getFieldsFieldExpressionParserRuleCall_1_0()); }
		ruleFieldExpression
		{ after(grammarAccess.getRecordExpressionAccess().getFieldsFieldExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RecordExpression__FieldsAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRecordExpressionAccess().getFieldsFieldExpressionParserRuleCall_2_1_0()); }
		ruleFieldExpression
		{ after(grammarAccess.getRecordExpressionAccess().getFieldsFieldExpressionParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FieldExpression__FieldAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldExpressionAccess().getFieldRecordFieldDeclarationUseCrossReference_0_0()); }
		(
			{ before(grammarAccess.getFieldExpressionAccess().getFieldRecordFieldDeclarationUseIDTerminalRuleCall_0_0_1()); }
			RULE_ID
			{ after(grammarAccess.getFieldExpressionAccess().getFieldRecordFieldDeclarationUseIDTerminalRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getFieldExpressionAccess().getFieldRecordFieldDeclarationUseCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FieldExpression__ValueAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldExpressionAccess().getValueExpressionParserRuleCall_2_0()); }
		ruleExpression
		{ after(grammarAccess.getFieldExpressionAccess().getValueExpressionParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__ValuesAssignment_2_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getArrayExpressionAccess().getValuesExpressionParserRuleCall_2_0_0()); }
		ruleExpression
		{ after(grammarAccess.getArrayExpressionAccess().getValuesExpressionParserRuleCall_2_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArrayExpression__ValuesAssignment_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getArrayExpressionAccess().getValuesExpressionParserRuleCall_2_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getArrayExpressionAccess().getValuesExpressionParserRuleCall_2_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__ValuesAssignment_2_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQueueExpressionAccess().getValuesExpressionParserRuleCall_2_0_0()); }
		ruleExpression
		{ after(grammarAccess.getQueueExpressionAccess().getValuesExpressionParserRuleCall_2_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QueueExpression__ValuesAssignment_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQueueExpressionAccess().getValuesExpressionParserRuleCall_2_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getQueueExpressionAccess().getValuesExpressionParserRuleCall_2_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__ElementAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEnqueueExpressionAccess().getElementExpressionParserRuleCall_2_0()); }
		ruleExpression
		{ after(grammarAccess.getEnqueueExpressionAccess().getElementExpressionParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnqueueExpression__QueueAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEnqueueExpressionAccess().getQueueExpressionParserRuleCall_4_0()); }
		ruleExpression
		{ after(grammarAccess.getEnqueueExpressionAccess().getQueueExpressionParserRuleCall_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__LeftAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAppendExpressionAccess().getLeftExpressionParserRuleCall_2_0()); }
		ruleExpression
		{ after(grammarAccess.getAppendExpressionAccess().getLeftExpressionParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AppendExpression__RightAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAppendExpressionAccess().getRightExpressionParserRuleCall_4_0()); }
		ruleExpression
		{ after(grammarAccess.getAppendExpressionAccess().getRightExpressionParserRuleCall_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalLiteral__ValueAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalLiteralAccess().getValueINTTerminalRuleCall_0()); }
		RULE_INT
		{ after(grammarAccess.getNaturalLiteralAccess().getValueINTTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalLowerBound__LeftAssignment_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
		(
			{ before(grammarAccess.getNaturalLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
			'['
			{ after(grammarAccess.getNaturalLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
		)
		{ after(grammarAccess.getNaturalLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalLowerBound__RightAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
		(
			{ before(grammarAccess.getNaturalLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
			']'
			{ after(grammarAccess.getNaturalLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
		)
		{ after(grammarAccess.getNaturalLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalLowerBound__ValueAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalLowerBoundAccess().getValueINTTerminalRuleCall_1_0()); }
		RULE_INT
		{ after(grammarAccess.getNaturalLowerBoundAccess().getValueINTTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalUpperBound__ValueAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalUpperBoundAccess().getValueINTTerminalRuleCall_0_0()); }
		RULE_INT
		{ after(grammarAccess.getNaturalUpperBoundAccess().getValueINTTerminalRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalUpperBound__LeftAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
		(
			{ before(grammarAccess.getNaturalUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
			'['
			{ after(grammarAccess.getNaturalUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
		)
		{ after(grammarAccess.getNaturalUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalUpperBound__RightAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
		(
			{ before(grammarAccess.getNaturalUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
			']'
			{ after(grammarAccess.getNaturalUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
		)
		{ after(grammarAccess.getNaturalUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalLowerBound__LeftAssignment_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDecimalLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
		(
			{ before(grammarAccess.getDecimalLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
			'['
			{ after(grammarAccess.getDecimalLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
		)
		{ after(grammarAccess.getDecimalLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalLowerBound__RightAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDecimalLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
		(
			{ before(grammarAccess.getDecimalLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
			']'
			{ after(grammarAccess.getDecimalLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
		)
		{ after(grammarAccess.getDecimalLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalLowerBound__ValueAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDecimalLowerBoundAccess().getValueFLTTerminalRuleCall_1_0()); }
		RULE_FLT
		{ after(grammarAccess.getDecimalLowerBoundAccess().getValueFLTTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalUpperBound__ValueAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDecimalUpperBoundAccess().getValueFLTTerminalRuleCall_0_0()); }
		RULE_FLT
		{ after(grammarAccess.getDecimalUpperBoundAccess().getValueFLTTerminalRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalUpperBound__LeftAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDecimalUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
		(
			{ before(grammarAccess.getDecimalUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
			'['
			{ after(grammarAccess.getDecimalUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
		)
		{ after(grammarAccess.getDecimalUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalUpperBound__RightAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDecimalUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
		(
			{ before(grammarAccess.getDecimalUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
			']'
			{ after(grammarAccess.getDecimalUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
		)
		{ after(grammarAccess.getDecimalUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableLowerBound__LeftAssignment_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
		(
			{ before(grammarAccess.getVariableLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
			'['
			{ after(grammarAccess.getVariableLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
		)
		{ after(grammarAccess.getVariableLowerBoundAccess().getLeftLeftSquareBracketKeyword_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableLowerBound__RightAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
		(
			{ before(grammarAccess.getVariableLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
			']'
			{ after(grammarAccess.getVariableLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
		)
		{ after(grammarAccess.getVariableLowerBoundAccess().getRightRightSquareBracketKeyword_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableLowerBound__VariableAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableLowerBoundAccess().getVariableBoundDeclarationUseCrossReference_1_0()); }
		(
			{ before(grammarAccess.getVariableLowerBoundAccess().getVariableBoundDeclarationUseIDTerminalRuleCall_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getVariableLowerBoundAccess().getVariableBoundDeclarationUseIDTerminalRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getVariableLowerBoundAccess().getVariableBoundDeclarationUseCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableUpperBound__VariableAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableUpperBoundAccess().getVariableBoundDeclarationUseCrossReference_0_0()); }
		(
			{ before(grammarAccess.getVariableUpperBoundAccess().getVariableBoundDeclarationUseIDTerminalRuleCall_0_0_1()); }
			RULE_ID
			{ after(grammarAccess.getVariableUpperBoundAccess().getVariableBoundDeclarationUseIDTerminalRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getVariableUpperBoundAccess().getVariableBoundDeclarationUseCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableUpperBound__LeftAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
		(
			{ before(grammarAccess.getVariableUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
			'['
			{ after(grammarAccess.getVariableUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
		)
		{ after(grammarAccess.getVariableUpperBoundAccess().getLeftLeftSquareBracketKeyword_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__VariableUpperBound__RightAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getVariableUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
		(
			{ before(grammarAccess.getVariableUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
			']'
			{ after(grammarAccess.getVariableUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
		)
		{ after(grammarAccess.getVariableUpperBoundAccess().getRightRightSquareBracketKeyword_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__PropertyAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRequirementAccess().getPropertyPropertyDeclarationCrossReference_1_0()); }
		(
			{ before(grammarAccess.getRequirementAccess().getPropertyPropertyDeclarationIDTerminalRuleCall_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getRequirementAccess().getPropertyPropertyDeclarationIDTerminalRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getRequirementAccess().getPropertyPropertyDeclarationCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__PositiveAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRequirementAccess().getPositiveSTRINGTerminalRuleCall_2_1_0()); }
		RULE_STRING
		{ after(grammarAccess.getRequirementAccess().getPositiveSTRINGTerminalRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Requirement__NegativeAssignment_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRequirementAccess().getNegativeSTRINGTerminalRuleCall_3_1_0()); }
		RULE_STRING
		{ after(grammarAccess.getRequirementAccess().getNegativeSTRINGTerminalRuleCall_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPropertyDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getPropertyDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDeclaration__PropertyAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPropertyDeclarationAccess().getPropertyPropertyParserRuleCall_3_0()); }
		ruleProperty
		{ after(grammarAccess.getPropertyDeclarationAccess().getPropertyPropertyParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__VariableAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedPropertyAccess().getVariableVariableDeclarationParserRuleCall_0_1_0()); }
		ruleVariableDeclaration
		{ after(grammarAccess.getQuantifiedPropertyAccess().getVariableVariableDeclarationParserRuleCall_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__TypeAssignment_0_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedPropertyAccess().getTypeRangeTypeParserRuleCall_0_3_0()); }
		ruleRangeType
		{ after(grammarAccess.getQuantifiedPropertyAccess().getTypeRangeTypeParserRuleCall_0_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QuantifiedProperty__ChildAssignment_0_5
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQuantifiedPropertyAccess().getChildQuantifiedPropertyParserRuleCall_0_5_0()); }
		ruleQuantifiedProperty
		{ after(grammarAccess.getQuantifiedPropertyAccess().getChildQuantifiedPropertyParserRuleCall_0_5_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyDisjunction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPropertyDisjunctionAccess().getRightPropertyImplicationParserRuleCall_1_2_0()); }
		rulePropertyImplication
		{ after(grammarAccess.getPropertyDisjunctionAccess().getRightPropertyImplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyImplication__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPropertyImplicationAccess().getRightPropertyImplicationParserRuleCall_1_2_0()); }
		rulePropertyImplication
		{ after(grammarAccess.getPropertyImplicationAccess().getRightPropertyImplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyConjunction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPropertyConjunctionAccess().getRightPropertyNegationParserRuleCall_1_2_0()); }
		rulePropertyNegation
		{ after(grammarAccess.getPropertyConjunctionAccess().getRightPropertyNegationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PropertyNegation__ChildAssignment_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPropertyNegationAccess().getChildPropertyNegationParserRuleCall_0_2_0()); }
		rulePropertyNegation
		{ after(grammarAccess.getPropertyNegationAccess().getChildPropertyNegationParserRuleCall_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLPattern__PropertyAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLPatternAccess().getPropertyLTLUnaryParserRuleCall_1_0()); }
		ruleLTLUnary
		{ after(grammarAccess.getLTLPatternAccess().getPropertyLTLUnaryParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__InfinitelyOftenPattern__SubjectAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getInfinitelyOftenPatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getInfinitelyOftenPatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MortalPattern__SubjectAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMortalPatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getMortalPatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__SubjectAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getPresencePatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__LastingAssignment_2_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getLastingINTTerminalRuleCall_2_0_1_0()); }
		RULE_INT
		{ after(grammarAccess.getPresencePatternAccess().getLastingINTTerminalRuleCall_2_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__AfterAssignment_2_1_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getAfterAtomicObservableParserRuleCall_2_1_0_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getPresencePatternAccess().getAfterAtomicObservableParserRuleCall_2_1_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__LowerAssignment_2_1_1_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getLowerLowerBoundParserRuleCall_2_1_1_0_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getPresencePatternAccess().getLowerLowerBoundParserRuleCall_2_1_1_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__UpperAssignment_2_1_1_0_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getUpperUpperBoundParserRuleCall_2_1_1_0_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getPresencePatternAccess().getUpperUpperBoundParserRuleCall_2_1_1_0_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__UntilAssignment_2_1_1_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getUntilAtomicObservableParserRuleCall_2_1_1_1_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getPresencePatternAccess().getUntilAtomicObservableParserRuleCall_2_1_1_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__BeforeAssignment_2_2_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getBeforeAtomicObservableParserRuleCall_2_2_0_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getPresencePatternAccess().getBeforeAtomicObservableParserRuleCall_2_2_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__LowerAssignment_2_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getLowerLowerBoundParserRuleCall_2_2_1_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getPresencePatternAccess().getLowerLowerBoundParserRuleCall_2_2_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__UpperAssignment_2_2_1_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getUpperUpperBoundParserRuleCall_2_2_1_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getPresencePatternAccess().getUpperUpperBoundParserRuleCall_2_2_1_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__MinAssignment_2_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getMinAtomicObservableParserRuleCall_2_3_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getPresencePatternAccess().getMinAtomicObservableParserRuleCall_2_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PresencePattern__MaxAssignment_2_3_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPresencePatternAccess().getMaxAtomicObservableParserRuleCall_2_3_3_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getPresencePatternAccess().getMaxAtomicObservableParserRuleCall_2_3_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__SubjectAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAbsencePatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__AfterAssignment_2_0_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getAfterAtomicObservableParserRuleCall_2_0_0_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAbsencePatternAccess().getAfterAtomicObservableParserRuleCall_2_0_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__LowerAssignment_2_0_1_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getLowerLowerBoundParserRuleCall_2_0_1_0_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getAbsencePatternAccess().getLowerLowerBoundParserRuleCall_2_0_1_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__UpperAssignment_2_0_1_0_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getUpperUpperBoundParserRuleCall_2_0_1_0_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getAbsencePatternAccess().getUpperUpperBoundParserRuleCall_2_0_1_0_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__UntilAssignment_2_0_1_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getUntilAtomicObservableParserRuleCall_2_0_1_1_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAbsencePatternAccess().getUntilAtomicObservableParserRuleCall_2_0_1_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__BeforeAssignment_2_1_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getBeforeAtomicObservableParserRuleCall_2_1_0_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAbsencePatternAccess().getBeforeAtomicObservableParserRuleCall_2_1_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__LowerAssignment_2_1_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getLowerLowerBoundParserRuleCall_2_1_1_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getAbsencePatternAccess().getLowerLowerBoundParserRuleCall_2_1_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__UpperAssignment_2_1_1_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getUpperUpperBoundParserRuleCall_2_1_1_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getAbsencePatternAccess().getUpperUpperBoundParserRuleCall_2_1_1_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__MinAssignment_2_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getMinAtomicObservableParserRuleCall_2_2_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAbsencePatternAccess().getMinAtomicObservableParserRuleCall_2_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AbsencePattern__MaxAssignment_2_2_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAbsencePatternAccess().getMaxAtomicObservableParserRuleCall_2_2_3_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAbsencePatternAccess().getMaxAtomicObservableParserRuleCall_2_2_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__SubjectAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAlwaysPatternAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__BeforeAssignment_2_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getBeforeAtomicObservableParserRuleCall_2_0_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAlwaysPatternAccess().getBeforeAtomicObservableParserRuleCall_2_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__AfterAssignment_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getAfterAtomicObservableParserRuleCall_2_1_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAlwaysPatternAccess().getAfterAtomicObservableParserRuleCall_2_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__UntilAssignment_2_1_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getUntilAtomicObservableParserRuleCall_2_1_2_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAlwaysPatternAccess().getUntilAtomicObservableParserRuleCall_2_1_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__MinAssignment_2_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getMinAtomicObservableParserRuleCall_2_2_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAlwaysPatternAccess().getMinAtomicObservableParserRuleCall_2_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AlwaysPattern__MaxAssignment_2_2_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAlwaysPatternAccess().getMaxAtomicObservableParserRuleCall_2_2_3_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getAlwaysPatternAccess().getMaxAtomicObservableParserRuleCall_2_2_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__FollowerAssignment_1_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getFollowerAtomicObservableParserRuleCall_1_0_2_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getFollowerAtomicObservableParserRuleCall_1_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__BeforeAssignment_1_0_3_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getBeforeAtomicObservableParserRuleCall_1_0_3_0_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getBeforeAtomicObservableParserRuleCall_1_0_3_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__LowerAssignment_1_0_3_0_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getLowerLowerBoundParserRuleCall_1_0_3_0_2_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getSequencePatternAccess().getLowerLowerBoundParserRuleCall_1_0_3_0_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__UpperAssignment_1_0_3_0_2_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getUpperUpperBoundParserRuleCall_1_0_3_0_2_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getSequencePatternAccess().getUpperUpperBoundParserRuleCall_1_0_3_0_2_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__LowerAssignment_1_0_3_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getLowerLowerBoundParserRuleCall_1_0_3_1_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getSequencePatternAccess().getLowerLowerBoundParserRuleCall_1_0_3_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__UpperAssignment_1_0_3_1_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getUpperUpperBoundParserRuleCall_1_0_3_1_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getSequencePatternAccess().getUpperUpperBoundParserRuleCall_1_0_3_1_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__AfterAssignment_1_0_3_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getAfterAtomicObservableParserRuleCall_1_0_3_2_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getAfterAtomicObservableParserRuleCall_1_0_3_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__LowerAssignment_1_0_3_2_2_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getLowerLowerBoundParserRuleCall_1_0_3_2_2_0_1_0()); }
		ruleLowerBound
		{ after(grammarAccess.getSequencePatternAccess().getLowerLowerBoundParserRuleCall_1_0_3_2_2_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__UpperAssignment_1_0_3_2_2_0_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getUpperUpperBoundParserRuleCall_1_0_3_2_2_0_3_0()); }
		ruleUpperBound
		{ after(grammarAccess.getSequencePatternAccess().getUpperUpperBoundParserRuleCall_1_0_3_2_2_0_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__UntilAssignment_1_0_3_2_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getUntilAtomicObservableParserRuleCall_1_0_3_2_2_1_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getUntilAtomicObservableParserRuleCall_1_0_3_2_2_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__MinAssignment_1_0_3_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getMinAtomicObservableParserRuleCall_1_0_3_3_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getMinAtomicObservableParserRuleCall_1_0_3_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__MaxAssignment_1_0_3_3_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getMaxAtomicObservableParserRuleCall_1_0_3_3_3_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getMaxAtomicObservableParserRuleCall_1_0_3_3_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__FollowerAssignment_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getFollowerAtomicObservableParserRuleCall_1_1_2_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getFollowerAtomicObservableParserRuleCall_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__BeforeAssignment_1_1_3_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getBeforeAtomicObservableParserRuleCall_1_1_3_0_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getBeforeAtomicObservableParserRuleCall_1_1_3_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__AfterAssignment_1_1_3_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getAfterAtomicObservableParserRuleCall_1_1_3_1_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getAfterAtomicObservableParserRuleCall_1_1_3_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__UntilAssignment_1_1_3_1_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getUntilAtomicObservableParserRuleCall_1_1_3_1_2_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getUntilAtomicObservableParserRuleCall_1_1_3_1_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__MinAssignment_1_1_3_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getMinAtomicObservableParserRuleCall_1_1_3_2_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getMinAtomicObservableParserRuleCall_1_1_3_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__SequencePattern__MaxAssignment_1_1_3_2_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getSequencePatternAccess().getMaxAtomicObservableParserRuleCall_1_1_3_2_3_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getSequencePatternAccess().getMaxAtomicObservableParserRuleCall_1_1_3_2_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__IndexAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLQuantifiedAccess().getIndexVariableDeclarationParserRuleCall_0_1_0()); }
		ruleVariableDeclaration
		{ after(grammarAccess.getLTLQuantifiedAccess().getIndexVariableDeclarationParserRuleCall_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__TypeAssignment_0_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLQuantifiedAccess().getTypeRangeTypeParserRuleCall_0_3_0()); }
		ruleRangeType
		{ after(grammarAccess.getLTLQuantifiedAccess().getTypeRangeTypeParserRuleCall_0_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLQuantified__ChildAssignment_0_5
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLQuantifiedAccess().getChildLTLQuantifiedParserRuleCall_0_5_0()); }
		ruleLTLQuantified
		{ after(grammarAccess.getLTLQuantifiedAccess().getChildLTLQuantifiedParserRuleCall_0_5_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLDisjunction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLDisjunctionAccess().getRightLTLImplicationParserRuleCall_1_2_0()); }
		ruleLTLImplication
		{ after(grammarAccess.getLTLDisjunctionAccess().getRightLTLImplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLImplication__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLImplicationAccess().getRightLTLImplicationParserRuleCall_1_2_0()); }
		ruleLTLImplication
		{ after(grammarAccess.getLTLImplicationAccess().getRightLTLImplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLConjunction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLConjunctionAccess().getRightLTLBinaryParserRuleCall_1_2_0()); }
		ruleLTLBinary
		{ after(grammarAccess.getLTLConjunctionAccess().getRightLTLBinaryParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__RightAssignment_1_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLBinaryAccess().getRightLTLUnaryParserRuleCall_1_0_2_0()); }
		ruleLTLUnary
		{ after(grammarAccess.getLTLBinaryAccess().getRightLTLUnaryParserRuleCall_1_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLBinary__RightAssignment_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLBinaryAccess().getRightLTLUnaryParserRuleCall_1_1_2_0()); }
		ruleLTLUnary
		{ after(grammarAccess.getLTLBinaryAccess().getRightLTLUnaryParserRuleCall_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LTLUnary__OperandAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLTLUnaryAccess().getOperandLTLUnaryParserRuleCall_0_1_0()); }
		ruleLTLUnary
		{ after(grammarAccess.getLTLUnaryAccess().getOperandLTLUnaryParserRuleCall_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicLTL__DeclarationAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAtomicLTLAccess().getDeclarationPropertyDeclarationUseCrossReference_0_1_0()); }
		(
			{ before(grammarAccess.getAtomicLTLAccess().getDeclarationPropertyDeclarationUseIDTerminalRuleCall_0_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getAtomicLTLAccess().getDeclarationPropertyDeclarationUseIDTerminalRuleCall_0_1_0_1()); }
		)
		{ after(grammarAccess.getAtomicLTLAccess().getDeclarationPropertyDeclarationUseCrossReference_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnterStateEvent__SubjectAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEnterStateEventAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getEnterStateEventAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LeaveStateEvent__SubjectAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLeaveStateEventAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
		ruleAtomicObservable
		{ after(grammarAccess.getLeaveStateEventAccess().getSubjectAtomicObservableParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableDisjunction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObservableDisjunctionAccess().getRightObservableImplicationParserRuleCall_1_2_0()); }
		ruleObservableImplication
		{ after(grammarAccess.getObservableDisjunctionAccess().getRightObservableImplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableImplication__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObservableImplicationAccess().getRightObservableImplicationParserRuleCall_1_2_0()); }
		ruleObservableImplication
		{ after(grammarAccess.getObservableImplicationAccess().getRightObservableImplicationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableConjunction__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObservableConjunctionAccess().getRightObservableNegationParserRuleCall_1_2_0()); }
		ruleObservableNegation
		{ after(grammarAccess.getObservableConjunctionAccess().getRightObservableNegationParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObservableNegation__ChildAssignment_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObservableNegationAccess().getChildObservableNegationParserRuleCall_0_2_0()); }
		ruleObservableNegation
		{ after(grammarAccess.getObservableNegationAccess().getChildObservableNegationParserRuleCall_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathEvent__PathAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathEventAccess().getPathPathParserRuleCall_0_0()); }
		rulePath
		{ after(grammarAccess.getPathEventAccess().getPathPathParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathEvent__ItemAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathEventAccess().getItemSubjectParserRuleCall_1_0()); }
		ruleSubject
		{ after(grammarAccess.getPathEventAccess().getItemSubjectParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Path__ItemsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathAccess().getItemsPathItemParserRuleCall_0_0()); }
		rulePathItem
		{ after(grammarAccess.getPathAccess().getItemsPathItemParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NaturalItem__ValueAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNaturalItemAccess().getValueINTTerminalRuleCall_0()); }
		RULE_INT
		{ after(grammarAccess.getNaturalItemAccess().getValueINTTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NamedItem__DeclarationAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNamedItemAccess().getDeclarationPathDeclarationUseCrossReference_0()); }
		(
			{ before(grammarAccess.getNamedItemAccess().getDeclarationPathDeclarationUseIDTerminalRuleCall_0_1()); }
			RULE_ID
			{ after(grammarAccess.getNamedItemAccess().getDeclarationPathDeclarationUseIDTerminalRuleCall_0_1()); }
		)
		{ after(grammarAccess.getNamedItemAccess().getDeclarationPathDeclarationUseCrossReference_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__StateSubject__StateAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStateSubjectAccess().getStateStateDeclarationCrossReference_1_0()); }
		(
			{ before(grammarAccess.getStateSubjectAccess().getStateStateDeclarationIDTerminalRuleCall_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getStateSubjectAccess().getStateStateDeclarationIDTerminalRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getStateSubjectAccess().getStateStateDeclarationCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ValueSubject__ValueAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getValueSubjectAccess().getValueAtomicExpressionParserRuleCall_1_0()); }
		ruleAtomicExpression
		{ after(grammarAccess.getValueSubjectAccess().getValueAtomicExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TagSubject__TagAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTagSubjectAccess().getTagTaggedStatementCrossReference_1_0()); }
		(
			{ before(grammarAccess.getTagSubjectAccess().getTagTaggedStatementIDTerminalRuleCall_1_0_1()); }
			RULE_ID
			{ after(grammarAccess.getTagSubjectAccess().getTagTaggedStatementIDTerminalRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getTagSubjectAccess().getTagTaggedStatementCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EventSubject__EventAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEventSubjectAccess().getEventIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getEventSubjectAccess().getEventIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

RULE_INT : ('0'..'9')+;

RULE_ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*;

RULE_FLT : RULE_INT '.' RULE_INT;

RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\'');

RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';

RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;

RULE_WS : (' '|'\t'|'\r'|'\n')+;

RULE_ANY_OTHER : .;
