/*
 * generated by Xtext 2.21.0
 */
parser grammar InternalSolverLanguageParser;

options {
	tokenVocab=InternalSolverLanguageLexer;
	superClass=AbstractInternalContentAssistParser;
}

@header {
package org.eclipse.viatra.solver.language.ide.contentassist.antlr.internal;
import java.util.Map;
import java.util.HashMap;

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 org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;

}
@members {
	private SolverLanguageGrammarAccess grammarAccess;
	private final Map<String, String> tokenNameToValue = new HashMap<String, String>();
	
	{
		tokenNameToValue.put("ExclamationMark", "'!'");
		tokenNameToValue.put("LeftParenthesis", "'('");
		tokenNameToValue.put("RightParenthesis", "')'");
		tokenNameToValue.put("Asterisk", "'*'");
		tokenNameToValue.put("PlusSign", "'+'");
		tokenNameToValue.put("Comma", "','");
		tokenNameToValue.put("HyphenMinus", "'-'");
		tokenNameToValue.put("FullStop", "'.'");
		tokenNameToValue.put("Solidus", "'/'");
		tokenNameToValue.put("Colon", "':'");
		tokenNameToValue.put("Semicolon", "';'");
		tokenNameToValue.put("LessThanSign", "'<'");
		tokenNameToValue.put("EqualsSign", "'='");
		tokenNameToValue.put("GreaterThanSign", "'>'");
		tokenNameToValue.put("QuestionMark", "'?'");
		tokenNameToValue.put("LeftSquareBracket", "'['");
		tokenNameToValue.put("RightSquareBracket", "']'");
		tokenNameToValue.put("CircumflexAccent", "'^'");
		tokenNameToValue.put("LeftCurlyBracket", "'{'");
		tokenNameToValue.put("VerticalLine", "'|'");
		tokenNameToValue.put("RightCurlyBracket", "'}'");
		tokenNameToValue.put("Tilde", "'~'");
		tokenNameToValue.put("ExclamationMarkEqualsSign", "'!='");
		tokenNameToValue.put("HyphenMinusGreaterThanSign", "'->'");
		tokenNameToValue.put("ColonHyphenMinus", "':-'");
		tokenNameToValue.put("ColonColon", "'::'");
		tokenNameToValue.put("ColonEqualsSign", "':='");
		tokenNameToValue.put("LessThanSignEqualsSign", "'<='");
		tokenNameToValue.put("EqualsSignEqualsSign", "'=='");
		tokenNameToValue.put("EqualsSignGreaterThanSign", "'=>'");
		tokenNameToValue.put("GreaterThanSignEqualsSign", "'>='");
		tokenNameToValue.put("As", "'as'");
		tokenNameToValue.put("If", "'if'");
		tokenNameToValue.put("In", "'in'");
		tokenNameToValue.put("FullStopFullStopFullStop", "'...'");
		tokenNameToValue.put("Inf", "'inf'");
		tokenNameToValue.put("Let", "'let'");
		tokenNameToValue.put("Else", "'else'");
		tokenNameToValue.put("Enum", "'enum'");
		tokenNameToValue.put("Root", "'root'");
		tokenNameToValue.put("Then", "'then'");
		tokenNameToValue.put("True", "'true'");
		tokenNameToValue.put("Class", "'class'");
		tokenNameToValue.put("Count", "'count'");
		tokenNameToValue.put("Empty", "'empty'");
		tokenNameToValue.put("Error", "'error'");
		tokenNameToValue.put("False", "'false'");
		tokenNameToValue.put("Scope", "'scope'");
		tokenNameToValue.put("Extern", "'extern'");
		tokenNameToValue.put("Import", "'import'");
		tokenNameToValue.put("Object", "'object'");
		tokenNameToValue.put("Refers", "'refers'");
		tokenNameToValue.put("Default", "'default'");
		tokenNameToValue.put("Extends", "'extends'");
		tokenNameToValue.put("Problem", "'problem'");
		tokenNameToValue.put("Unknown", "'unknown'");
		tokenNameToValue.put("Abstract", "'abstract'");
		tokenNameToValue.put("Contains", "'contains'");
		tokenNameToValue.put("Datatype", "'datatype'");
		tokenNameToValue.put("Maximize", "'maximize'");
		tokenNameToValue.put("Minimize", "'minimize'");
		tokenNameToValue.put("Opposite", "'opposite'");
		tokenNameToValue.put("Functional", "'functional'");
		tokenNameToValue.put("Containment", "'containment'");
	}

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

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

	@Override
	protected String getValueForTokenName(String tokenName) {
		String result = tokenNameToValue.get(tokenName);
		if (result == null)
			result = tokenName;
		return result;
	}
}

// Entry rule entryRuleProblem
entryRuleProblem
:
{ before(grammarAccess.getProblemRule()); }
	 ruleProblem
{ after(grammarAccess.getProblemRule()); } 
	 EOF 
;

// Rule Problem
ruleProblem 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getProblemAccess().getGroup()); }
		(rule__Problem__Group__0)
		{ after(grammarAccess.getProblemAccess().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 entryRuleImport
entryRuleImport
:
{ before(grammarAccess.getImportRule()); }
	 ruleImport
{ after(grammarAccess.getImportRule()); } 
	 EOF 
;

// Rule Import
ruleImport 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getImportAccess().getAlternatives()); }
		(rule__Import__Alternatives)
		{ after(grammarAccess.getImportAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUriImport
entryRuleUriImport
:
{ before(grammarAccess.getUriImportRule()); }
	 ruleUriImport
{ after(grammarAccess.getUriImportRule()); } 
	 EOF 
;

// Rule UriImport
ruleUriImport 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUriImportAccess().getGroup()); }
		(rule__UriImport__Group__0)
		{ after(grammarAccess.getUriImportAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleNamespaceImport
entryRuleNamespaceImport
:
{ before(grammarAccess.getNamespaceImportRule()); }
	 ruleNamespaceImport
{ after(grammarAccess.getNamespaceImportRule()); } 
	 EOF 
;

// Rule NamespaceImport
ruleNamespaceImport 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getNamespaceImportAccess().getGroup()); }
		(rule__NamespaceImport__Group__0)
		{ after(grammarAccess.getNamespaceImportAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAssertionOrDefinition
entryRuleAssertionOrDefinition
:
{ before(grammarAccess.getAssertionOrDefinitionRule()); }
	 ruleAssertionOrDefinition
{ after(grammarAccess.getAssertionOrDefinitionRule()); } 
	 EOF 
;

// Rule AssertionOrDefinition
ruleAssertionOrDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); }
		(rule__AssertionOrDefinition__Group__0)
		{ after(grammarAccess.getAssertionOrDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePredicateDefinition
entryRulePredicateDefinition
:
{ before(grammarAccess.getPredicateDefinitionRule()); }
	 rulePredicateDefinition
{ after(grammarAccess.getPredicateDefinitionRule()); } 
	 EOF 
;

// Rule PredicateDefinition
rulePredicateDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getGroup()); }
		(rule__PredicateDefinition__Group__0)
		{ after(grammarAccess.getPredicateDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUnnamedErrorPredicateDefintion
entryRuleUnnamedErrorPredicateDefintion
:
{ before(grammarAccess.getUnnamedErrorPredicateDefintionRule()); }
	 ruleUnnamedErrorPredicateDefintion
{ after(grammarAccess.getUnnamedErrorPredicateDefintionRule()); } 
	 EOF 
;

// Rule UnnamedErrorPredicateDefintion
ruleUnnamedErrorPredicateDefintion 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getGroup()); }
		(rule__UnnamedErrorPredicateDefintion__Group__0)
		{ after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDefaultAssertion
entryRuleDefaultAssertion
:
{ before(grammarAccess.getDefaultAssertionRule()); }
	 ruleDefaultAssertion
{ after(grammarAccess.getDefaultAssertionRule()); } 
	 EOF 
;

// Rule DefaultAssertion
ruleDefaultAssertion 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDefaultAssertionAccess().getGroup()); }
		(rule__DefaultAssertion__Group__0)
		{ after(grammarAccess.getDefaultAssertionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleFunctionDefinition
entryRuleFunctionDefinition
:
{ before(grammarAccess.getFunctionDefinitionRule()); }
	 ruleFunctionDefinition
{ after(grammarAccess.getFunctionDefinitionRule()); } 
	 EOF 
;

// Rule FunctionDefinition
ruleFunctionDefinition 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getFunctionDefinitionAccess().getGroup()); }
		(rule__FunctionDefinition__Group__0)
		{ after(grammarAccess.getFunctionDefinitionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTypeReference
entryRuleTypeReference
:
{ before(grammarAccess.getTypeReferenceRule()); }
	 ruleTypeReference
{ after(grammarAccess.getTypeReferenceRule()); } 
	 EOF 
;

// Rule TypeReference
ruleTypeReference 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTypeReferenceAccess().getGroup()); }
		(rule__TypeReference__Group__0)
		{ after(grammarAccess.getTypeReferenceAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAttribute
entryRuleAttribute
:
{ before(grammarAccess.getAttributeRule()); }
	 ruleAttribute
{ after(grammarAccess.getAttributeRule()); } 
	 EOF 
;

// Rule Attribute
ruleAttribute 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAttributeAccess().getGroup()); }
		(rule__Attribute__Group__0)
		{ after(grammarAccess.getAttributeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternDeclaration
entryRuleExternDeclaration
:
{ before(grammarAccess.getExternDeclarationRule()); }
	 ruleExternDeclaration
{ after(grammarAccess.getExternDeclarationRule()); } 
	 EOF 
;

// Rule ExternDeclaration
ruleExternDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternDeclarationAccess().getAlternatives()); }
		(rule__ExternDeclaration__Alternatives)
		{ after(grammarAccess.getExternDeclarationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternPredicateDeclaration
entryRuleExternPredicateDeclaration
:
{ before(grammarAccess.getExternPredicateDeclarationRule()); }
	 ruleExternPredicateDeclaration
{ after(grammarAccess.getExternPredicateDeclarationRule()); } 
	 EOF 
;

// Rule ExternPredicateDeclaration
ruleExternPredicateDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternPredicateDeclarationAccess().getGroup()); }
		(rule__ExternPredicateDeclaration__Group__0)
		{ after(grammarAccess.getExternPredicateDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternFunctionDeclaration
entryRuleExternFunctionDeclaration
:
{ before(grammarAccess.getExternFunctionDeclarationRule()); }
	 ruleExternFunctionDeclaration
{ after(grammarAccess.getExternFunctionDeclarationRule()); } 
	 EOF 
;

// Rule ExternFunctionDeclaration
ruleExternFunctionDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternFunctionDeclarationAccess().getGroup()); }
		(rule__ExternFunctionDeclaration__Group__0)
		{ after(grammarAccess.getExternFunctionDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternAggregationOperatorDeclaration
entryRuleExternAggregationOperatorDeclaration
:
{ before(grammarAccess.getExternAggregationOperatorDeclarationRule()); }
	 ruleExternAggregationOperatorDeclaration
{ after(grammarAccess.getExternAggregationOperatorDeclarationRule()); } 
	 EOF 
;

// Rule ExternAggregationOperatorDeclaration
ruleExternAggregationOperatorDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getGroup()); }
		(rule__ExternAggregationOperatorDeclaration__Group__0)
		{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExternDatatypeDeclaration
entryRuleExternDatatypeDeclaration
:
{ before(grammarAccess.getExternDatatypeDeclarationRule()); }
	 ruleExternDatatypeDeclaration
{ after(grammarAccess.getExternDatatypeDeclarationRule()); } 
	 EOF 
;

// Rule ExternDatatypeDeclaration
ruleExternDatatypeDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExternDatatypeDeclarationAccess().getGroup()); }
		(rule__ExternDatatypeDeclaration__Group__0)
		{ after(grammarAccess.getExternDatatypeDeclarationAccess().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().getAlternatives()); }
		(rule__Expression__Alternatives)
		{ after(grammarAccess.getExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleConditionalExpression
entryRuleConditionalExpression
:
{ before(grammarAccess.getConditionalExpressionRule()); }
	 ruleConditionalExpression
{ after(grammarAccess.getConditionalExpressionRule()); } 
	 EOF 
;

// Rule ConditionalExpression
ruleConditionalExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getConditionalExpressionAccess().getGroup()); }
		(rule__ConditionalExpression__Group__0)
		{ after(grammarAccess.getConditionalExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLetExpression
entryRuleLetExpression
:
{ before(grammarAccess.getLetExpressionRule()); }
	 ruleLetExpression
{ after(grammarAccess.getLetExpressionRule()); } 
	 EOF 
;

// Rule LetExpression
ruleLetExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLetExpressionAccess().getGroup()); }
		(rule__LetExpression__Group__0)
		{ after(grammarAccess.getLetExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLetBinding
entryRuleLetBinding
:
{ before(grammarAccess.getLetBindingRule()); }
	 ruleLetBinding
{ after(grammarAccess.getLetBindingRule()); } 
	 EOF 
;

// Rule LetBinding
ruleLetBinding 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLetBindingAccess().getGroup()); }
		(rule__LetBinding__Group__0)
		{ after(grammarAccess.getLetBindingAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleDisjunctiveExpression
entryRuleDisjunctiveExpression
:
{ before(grammarAccess.getDisjunctiveExpressionRule()); }
	 ruleDisjunctiveExpression
{ after(grammarAccess.getDisjunctiveExpressionRule()); } 
	 EOF 
;

// Rule DisjunctiveExpression
ruleDisjunctiveExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); }
		(rule__DisjunctiveExpression__Group__0)
		{ after(grammarAccess.getDisjunctiveExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleCase
entryRuleCase
:
{ before(grammarAccess.getCaseRule()); }
	 ruleCase
{ after(grammarAccess.getCaseRule()); } 
	 EOF 
;

// Rule Case
ruleCase 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getCaseAccess().getGroup()); }
		(rule__Case__Group__0)
		{ after(grammarAccess.getCaseAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleConjunctiveExpression
entryRuleConjunctiveExpression
:
{ before(grammarAccess.getConjunctiveExpressionRule()); }
	 ruleConjunctiveExpression
{ after(grammarAccess.getConjunctiveExpressionRule()); } 
	 EOF 
;

// Rule ConjunctiveExpression
ruleConjunctiveExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getConjunctiveExpressionAccess().getGroup()); }
		(rule__ConjunctiveExpression__Group__0)
		{ after(grammarAccess.getConjunctiveExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleComparisonExpression
entryRuleComparisonExpression
:
{ before(grammarAccess.getComparisonExpressionRule()); }
	 ruleComparisonExpression
{ after(grammarAccess.getComparisonExpressionRule()); } 
	 EOF 
;

// Rule ComparisonExpression
ruleComparisonExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getComparisonExpressionAccess().getGroup()); }
		(rule__ComparisonExpression__Group__0)
		{ after(grammarAccess.getComparisonExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAdditiveExpression
entryRuleAdditiveExpression
:
{ before(grammarAccess.getAdditiveExpressionRule()); }
	 ruleAdditiveExpression
{ after(grammarAccess.getAdditiveExpressionRule()); } 
	 EOF 
;

// Rule AdditiveExpression
ruleAdditiveExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
		(rule__AdditiveExpression__Group__0)
		{ after(grammarAccess.getAdditiveExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleMultiplicativeExpression
entryRuleMultiplicativeExpression
:
{ before(grammarAccess.getMultiplicativeExpressionRule()); }
	 ruleMultiplicativeExpression
{ after(grammarAccess.getMultiplicativeExpressionRule()); } 
	 EOF 
;

// Rule MultiplicativeExpression
ruleMultiplicativeExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
		(rule__MultiplicativeExpression__Group__0)
		{ after(grammarAccess.getMultiplicativeExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExponentialExpression
entryRuleExponentialExpression
:
{ before(grammarAccess.getExponentialExpressionRule()); }
	 ruleExponentialExpression
{ after(grammarAccess.getExponentialExpressionRule()); } 
	 EOF 
;

// Rule ExponentialExpression
ruleExponentialExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExponentialExpressionAccess().getGroup()); }
		(rule__ExponentialExpression__Group__0)
		{ after(grammarAccess.getExponentialExpressionAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleCastExpression
entryRuleCastExpression
:
{ before(grammarAccess.getCastExpressionRule()); }
	 ruleCastExpression
{ after(grammarAccess.getCastExpressionRule()); } 
	 EOF 
;

// Rule CastExpression
ruleCastExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getCastExpressionAccess().getGroup()); }
		(rule__CastExpression__Group__0)
		{ after(grammarAccess.getCastExpressionAccess().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 entryRuleBracedAggregateExpression
entryRuleBracedAggregateExpression
:
{ before(grammarAccess.getBracedAggregateExpressionRule()); }
	 ruleBracedAggregateExpression
{ after(grammarAccess.getBracedAggregateExpressionRule()); } 
	 EOF 
;

// Rule BracedAggregateExpression
ruleBracedAggregateExpression 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getBracedAggregateExpressionAccess().getAlternatives()); }
		(rule__BracedAggregateExpression__Alternatives)
		{ after(grammarAccess.getBracedAggregateExpressionAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleAggregation
entryRuleAggregation
:
{ before(grammarAccess.getAggregationRule()); }
	 ruleAggregation
{ after(grammarAccess.getAggregationRule()); } 
	 EOF 
;

// Rule Aggregation
ruleAggregation 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getAggregationAccess().getGroup()); }
		(rule__Aggregation__Group__0)
		{ after(grammarAccess.getAggregationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleCount
entryRuleCount
:
{ before(grammarAccess.getCountRule()); }
	 ruleCount
{ after(grammarAccess.getCountRule()); } 
	 EOF 
;

// Rule Count
ruleCount 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getCountAccess().getGroup()); }
		(rule__Count__Group__0)
		{ after(grammarAccess.getCountAccess().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 entryRuleCall
entryRuleCall
:
{ before(grammarAccess.getCallRule()); }
	 ruleCall
{ after(grammarAccess.getCallRule()); } 
	 EOF 
;

// Rule Call
ruleCall 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getCallAccess().getGroup()); }
		(rule__Call__Group__0)
		{ after(grammarAccess.getCallAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleArgumentList
entryRuleArgumentList
:
{ before(grammarAccess.getArgumentListRule()); }
	 ruleArgumentList
{ after(grammarAccess.getArgumentListRule()); } 
	 EOF 
;

// Rule ArgumentList
ruleArgumentList 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getArgumentListAccess().getGroup()); }
		(rule__ArgumentList__Group__0)
		{ after(grammarAccess.getArgumentListAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleArgument
entryRuleArgument
:
{ before(grammarAccess.getArgumentRule()); }
	 ruleArgument
{ after(grammarAccess.getArgumentRule()); } 
	 EOF 
;

// Rule Argument
ruleArgument 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getArgumentAccess().getAlternatives()); }
		(rule__Argument__Alternatives)
		{ after(grammarAccess.getArgumentAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExpressionArgument
entryRuleExpressionArgument
:
{ before(grammarAccess.getExpressionArgumentRule()); }
	 ruleExpressionArgument
{ after(grammarAccess.getExpressionArgumentRule()); } 
	 EOF 
;

// Rule ExpressionArgument
ruleExpressionArgument 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExpressionArgumentAccess().getExpressionAssignment()); }
		(rule__ExpressionArgument__ExpressionAssignment)
		{ after(grammarAccess.getExpressionArgumentAccess().getExpressionAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleStarArgument
entryRuleStarArgument
:
{ before(grammarAccess.getStarArgumentRule()); }
	 ruleStarArgument
{ after(grammarAccess.getStarArgumentRule()); } 
	 EOF 
;

// Rule StarArgument
ruleStarArgument 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getStarArgumentAccess().getGroup()); }
		(rule__StarArgument__Group__0)
		{ after(grammarAccess.getStarArgumentAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTypedVariableArgument
entryRuleTypedVariableArgument
:
{ before(grammarAccess.getTypedVariableArgumentRule()); }
	 ruleTypedVariableArgument
{ after(grammarAccess.getTypedVariableArgumentRule()); } 
	 EOF 
;

// Rule TypedVariableArgument
ruleTypedVariableArgument 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTypedVariableArgumentAccess().getGroup()); }
		(rule__TypedVariableArgument__Group__0)
		{ after(grammarAccess.getTypedVariableArgumentAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleTypedStarArgument
entryRuleTypedStarArgument
:
{ before(grammarAccess.getTypedStarArgumentRule()); }
	 ruleTypedStarArgument
{ after(grammarAccess.getTypedStarArgumentRule()); } 
	 EOF 
;

// Rule TypedStarArgument
ruleTypedStarArgument 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getTypedStarArgumentAccess().getGroup()); }
		(rule__TypedStarArgument__Group__0)
		{ after(grammarAccess.getTypedStarArgumentAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleReference
entryRuleReference
:
{ before(grammarAccess.getReferenceRule()); }
	 ruleReference
{ after(grammarAccess.getReferenceRule()); } 
	 EOF 
;

// Rule Reference
ruleReference 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getReferenceAccess().getGroup()); }
		(rule__Reference__Group__0)
		{ after(grammarAccess.getReferenceAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRulePathComponent
entryRulePathComponent
:
{ before(grammarAccess.getPathComponentRule()); }
	 rulePathComponent
{ after(grammarAccess.getPathComponentRule()); } 
	 EOF 
;

// Rule PathComponent
rulePathComponent 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getPathComponentAccess().getGroup()); }
		(rule__PathComponent__Group__0)
		{ after(grammarAccess.getPathComponentAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleInterval
entryRuleInterval
:
{ before(grammarAccess.getIntervalRule()); }
	 ruleInterval
{ after(grammarAccess.getIntervalRule()); } 
	 EOF 
;

// Rule Interval
ruleInterval 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getIntervalAccess().getGroup()); }
		(rule__Interval__Group__0)
		{ after(grammarAccess.getIntervalAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLiteral
entryRuleLiteral
:
{ before(grammarAccess.getLiteralRule()); }
	 ruleLiteral
{ after(grammarAccess.getLiteralRule()); } 
	 EOF 
;

// Rule Literal
ruleLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLiteralAccess().getAlternatives()); }
		(rule__Literal__Alternatives)
		{ after(grammarAccess.getLiteralAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLogicLiteral
entryRuleLogicLiteral
:
{ before(grammarAccess.getLogicLiteralRule()); }
	 ruleLogicLiteral
{ after(grammarAccess.getLogicLiteralRule()); } 
	 EOF 
;

// Rule LogicLiteral
ruleLogicLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLogicLiteralAccess().getValueAssignment()); }
		(rule__LogicLiteral__ValueAssignment)
		{ after(grammarAccess.getLogicLiteralAccess().getValueAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleIntLiteral
entryRuleIntLiteral
:
{ before(grammarAccess.getIntLiteralRule()); }
	 ruleIntLiteral
{ after(grammarAccess.getIntLiteralRule()); } 
	 EOF 
;

// Rule IntLiteral
ruleIntLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getIntLiteralAccess().getValueAssignment()); }
		(rule__IntLiteral__ValueAssignment)
		{ after(grammarAccess.getIntLiteralAccess().getValueAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleRealLiteral
entryRuleRealLiteral
:
{ before(grammarAccess.getRealLiteralRule()); }
	 ruleRealLiteral
{ after(grammarAccess.getRealLiteralRule()); } 
	 EOF 
;

// Rule RealLiteral
ruleRealLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRealLiteralAccess().getValueAssignment()); }
		(rule__RealLiteral__ValueAssignment)
		{ after(grammarAccess.getRealLiteralAccess().getValueAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleInfinityLiteral
entryRuleInfinityLiteral
:
{ before(grammarAccess.getInfinityLiteralRule()); }
	 ruleInfinityLiteral
{ after(grammarAccess.getInfinityLiteralRule()); } 
	 EOF 
;

// Rule InfinityLiteral
ruleInfinityLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getInfinityLiteralAccess().getGroup()); }
		(rule__InfinityLiteral__Group__0)
		{ after(grammarAccess.getInfinityLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleEmptyLiteral
entryRuleEmptyLiteral
:
{ before(grammarAccess.getEmptyLiteralRule()); }
	 ruleEmptyLiteral
{ after(grammarAccess.getEmptyLiteralRule()); } 
	 EOF 
;

// Rule EmptyLiteral
ruleEmptyLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getEmptyLiteralAccess().getGroup()); }
		(rule__EmptyLiteral__Group__0)
		{ after(grammarAccess.getEmptyLiteralAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleStringLiteral
entryRuleStringLiteral
:
{ before(grammarAccess.getStringLiteralRule()); }
	 ruleStringLiteral
{ after(grammarAccess.getStringLiteralRule()); } 
	 EOF 
;

// Rule StringLiteral
ruleStringLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getStringLiteralAccess().getValueAssignment()); }
		(rule__StringLiteral__ValueAssignment)
		{ after(grammarAccess.getStringLiteralAccess().getValueAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleClassDeclaration
entryRuleClassDeclaration
:
{ before(grammarAccess.getClassDeclarationRule()); }
	 ruleClassDeclaration
{ after(grammarAccess.getClassDeclarationRule()); } 
	 EOF 
;

// Rule ClassDeclaration
ruleClassDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getClassDeclarationAccess().getGroup()); }
		(rule__ClassDeclaration__Group__0)
		{ after(grammarAccess.getClassDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleField
entryRuleField
:
{ before(grammarAccess.getFieldRule()); }
	 ruleField
{ after(grammarAccess.getFieldRule()); } 
	 EOF 
;

// Rule Field
ruleField 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getFieldAccess().getGroup()); }
		(rule__Field__Group__0)
		{ after(grammarAccess.getFieldAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleMultiplicity
entryRuleMultiplicity
:
{ before(grammarAccess.getMultiplicityRule()); }
	 ruleMultiplicity
{ after(grammarAccess.getMultiplicityRule()); } 
	 EOF 
;

// Rule Multiplicity
ruleMultiplicity 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getMultiplicityAccess().getAlternatives()); }
		(rule__Multiplicity__Alternatives)
		{ after(grammarAccess.getMultiplicityAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUnboundedMultiplicity
entryRuleUnboundedMultiplicity
:
{ before(grammarAccess.getUnboundedMultiplicityRule()); }
	 ruleUnboundedMultiplicity
{ after(grammarAccess.getUnboundedMultiplicityRule()); } 
	 EOF 
;

// Rule UnboundedMultiplicity
ruleUnboundedMultiplicity 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUnboundedMultiplicityAccess().getGroup()); }
		(rule__UnboundedMultiplicity__Group__0)
		{ after(grammarAccess.getUnboundedMultiplicityAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExactMultiplicity
entryRuleExactMultiplicity
:
{ before(grammarAccess.getExactMultiplicityRule()); }
	 ruleExactMultiplicity
{ after(grammarAccess.getExactMultiplicityRule()); } 
	 EOF 
;

// Rule ExactMultiplicity
ruleExactMultiplicity 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExactMultiplicityAccess().getGroup()); }
		(rule__ExactMultiplicity__Group__0)
		{ after(grammarAccess.getExactMultiplicityAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleBoundedMultiplicity
entryRuleBoundedMultiplicity
:
{ before(grammarAccess.getBoundedMultiplicityRule()); }
	 ruleBoundedMultiplicity
{ after(grammarAccess.getBoundedMultiplicityRule()); } 
	 EOF 
;

// Rule BoundedMultiplicity
ruleBoundedMultiplicity 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getBoundedMultiplicityAccess().getGroup()); }
		(rule__BoundedMultiplicity__Group__0)
		{ after(grammarAccess.getBoundedMultiplicityAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleEnumDeclaration
entryRuleEnumDeclaration
:
{ before(grammarAccess.getEnumDeclarationRule()); }
	 ruleEnumDeclaration
{ after(grammarAccess.getEnumDeclarationRule()); } 
	 EOF 
;

// Rule EnumDeclaration
ruleEnumDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getEnumDeclarationAccess().getGroup()); }
		(rule__EnumDeclaration__Group__0)
		{ after(grammarAccess.getEnumDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleEnumLiteral
entryRuleEnumLiteral
:
{ before(grammarAccess.getEnumLiteralRule()); }
	 ruleEnumLiteral
{ after(grammarAccess.getEnumLiteralRule()); } 
	 EOF 
;

// Rule EnumLiteral
ruleEnumLiteral 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getEnumLiteralAccess().getNameAssignment()); }
		(rule__EnumLiteral__NameAssignment)
		{ after(grammarAccess.getEnumLiteralAccess().getNameAssignment()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleScopeDeclaration
entryRuleScopeDeclaration
:
{ before(grammarAccess.getScopeDeclarationRule()); }
	 ruleScopeDeclaration
{ after(grammarAccess.getScopeDeclarationRule()); } 
	 EOF 
;

// Rule ScopeDeclaration
ruleScopeDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getScopeDeclarationAccess().getAlternatives()); }
		(rule__ScopeDeclaration__Alternatives)
		{ after(grammarAccess.getScopeDeclarationAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleExactScope
entryRuleExactScope
:
{ before(grammarAccess.getExactScopeRule()); }
	 ruleExactScope
{ after(grammarAccess.getExactScopeRule()); } 
	 EOF 
;

// Rule ExactScope
ruleExactScope 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getExactScopeAccess().getGroup()); }
		(rule__ExactScope__Group__0)
		{ after(grammarAccess.getExactScopeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleBoundedScope
entryRuleBoundedScope
:
{ before(grammarAccess.getBoundedScopeRule()); }
	 ruleBoundedScope
{ after(grammarAccess.getBoundedScopeRule()); } 
	 EOF 
;

// Rule BoundedScope
ruleBoundedScope 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getBoundedScopeAccess().getGroup()); }
		(rule__BoundedScope__Group__0)
		{ after(grammarAccess.getBoundedScopeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleLowerBoundedScope
entryRuleLowerBoundedScope
:
{ before(grammarAccess.getLowerBoundedScopeRule()); }
	 ruleLowerBoundedScope
{ after(grammarAccess.getLowerBoundedScopeRule()); } 
	 EOF 
;

// Rule LowerBoundedScope
ruleLowerBoundedScope 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getLowerBoundedScopeAccess().getGroup()); }
		(rule__LowerBoundedScope__Group__0)
		{ after(grammarAccess.getLowerBoundedScopeAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleObjectiveDeclaration
entryRuleObjectiveDeclaration
:
{ before(grammarAccess.getObjectiveDeclarationRule()); }
	 ruleObjectiveDeclaration
{ after(grammarAccess.getObjectiveDeclarationRule()); } 
	 EOF 
;

// Rule ObjectiveDeclaration
ruleObjectiveDeclaration 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getObjectiveDeclarationAccess().getGroup()); }
		(rule__ObjectiveDeclaration__Group__0)
		{ after(grammarAccess.getObjectiveDeclarationAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleUpperMultiplicty
entryRuleUpperMultiplicty
:
{ before(grammarAccess.getUpperMultiplictyRule()); }
	 ruleUpperMultiplicty
{ after(grammarAccess.getUpperMultiplictyRule()); } 
	 EOF 
;

// Rule UpperMultiplicty
ruleUpperMultiplicty 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); }
		(rule__UpperMultiplicty__Alternatives)
		{ after(grammarAccess.getUpperMultiplictyAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleReal
entryRuleReal
@init { 
	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
}
:
{ before(grammarAccess.getRealRule()); }
	 ruleReal
{ after(grammarAccess.getRealRule()); } 
	 EOF 
;
finally {
	myHiddenTokenState.restore();
}

// Rule Real
ruleReal 
	@init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getRealAccess().getGroup()); }
		(rule__Real__Group__0)
		{ after(grammarAccess.getRealAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
	myHiddenTokenState.restore();
}

// Entry rule entryRuleQualifiedNameSegment
entryRuleQualifiedNameSegment
:
{ before(grammarAccess.getQualifiedNameSegmentRule()); }
	 ruleQualifiedNameSegment
{ after(grammarAccess.getQualifiedNameSegmentRule()); } 
	 EOF 
;

// Rule QualifiedNameSegment
ruleQualifiedNameSegment 
	@init {
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getQualifiedNameSegmentAccess().getAlternatives()); }
		(rule__QualifiedNameSegment__Alternatives)
		{ after(grammarAccess.getQualifiedNameSegmentAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Entry rule entryRuleQualifiedName
entryRuleQualifiedName
@init { 
	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
}
:
{ before(grammarAccess.getQualifiedNameRule()); }
	 ruleQualifiedName
{ after(grammarAccess.getQualifiedNameRule()); } 
	 EOF 
;
finally {
	myHiddenTokenState.restore();
}

// Rule QualifiedName
ruleQualifiedName 
	@init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
	}
	:
	(
		{ before(grammarAccess.getQualifiedNameAccess().getGroup()); }
		(rule__QualifiedName__Group__0)
		{ after(grammarAccess.getQualifiedNameAccess().getGroup()); }
	)
;
finally {
	restoreStackSize(stackSize);
	myHiddenTokenState.restore();
}

// Rule AttributeKind
ruleAttributeKind
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAttributeKindAccess().getAlternatives()); }
		(rule__AttributeKind__Alternatives)
		{ after(grammarAccess.getAttributeKindAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Rule ComparisonOperator
ruleComparisonOperator
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getAlternatives()); }
		(rule__ComparisonOperator__Alternatives)
		{ after(grammarAccess.getComparisonOperatorAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Rule AdditiveBinaryOperator
ruleAdditiveBinaryOperator
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); }
		(rule__AdditiveBinaryOperator__Alternatives)
		{ after(grammarAccess.getAdditiveBinaryOperatorAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Rule MultiplicativeBinaryOperator
ruleMultiplicativeBinaryOperator
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); }
		(rule__MultiplicativeBinaryOperator__Alternatives)
		{ after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Rule ExponentialOp
ruleExponentialOp
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); }
		(CircumflexAccent)
		{ after(grammarAccess.getExponentialOpAccess().getPOWEnumLiteralDeclaration()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Rule UnaryOperator
ruleUnaryOperator
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryOperatorAccess().getAlternatives()); }
		(rule__UnaryOperator__Alternatives)
		{ after(grammarAccess.getUnaryOperatorAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Rule LogicValue
ruleLogicValue
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLogicValueAccess().getAlternatives()); }
		(rule__LogicValue__Alternatives)
		{ after(grammarAccess.getLogicValueAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

// Rule ObjectiveKind
ruleObjectiveKind
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObjectiveKindAccess().getAlternatives()); }
		(rule__ObjectiveKind__Alternatives)
		{ after(grammarAccess.getObjectiveKindAccess().getAlternatives()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Statement__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0()); }
		ruleAssertionOrDefinition
		{ after(grammarAccess.getStatementAccess().getAssertionOrDefinitionParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_1()); }
		rulePredicateDefinition
		{ after(grammarAccess.getStatementAccess().getPredicateDefinitionParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getUnnamedErrorPredicateDefintionParserRuleCall_2()); }
		ruleUnnamedErrorPredicateDefintion
		{ after(grammarAccess.getStatementAccess().getUnnamedErrorPredicateDefintionParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getDefaultAssertionParserRuleCall_3()); }
		ruleDefaultAssertion
		{ after(grammarAccess.getStatementAccess().getDefaultAssertionParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getFunctionDefinitionParserRuleCall_4()); }
		ruleFunctionDefinition
		{ after(grammarAccess.getStatementAccess().getFunctionDefinitionParserRuleCall_4()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getAttributeParserRuleCall_5()); }
		ruleAttribute
		{ after(grammarAccess.getStatementAccess().getAttributeParserRuleCall_5()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getExternDeclarationParserRuleCall_6()); }
		ruleExternDeclaration
		{ after(grammarAccess.getStatementAccess().getExternDeclarationParserRuleCall_6()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_7()); }
		ruleScopeDeclaration
		{ after(grammarAccess.getStatementAccess().getScopeDeclarationParserRuleCall_7()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getObjectiveDeclarationParserRuleCall_8()); }
		ruleObjectiveDeclaration
		{ after(grammarAccess.getStatementAccess().getObjectiveDeclarationParserRuleCall_8()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_9()); }
		ruleClassDeclaration
		{ after(grammarAccess.getStatementAccess().getClassDeclarationParserRuleCall_9()); }
	)
	|
	(
		{ before(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_10()); }
		ruleEnumDeclaration
		{ after(grammarAccess.getStatementAccess().getEnumDeclarationParserRuleCall_10()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Import__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getImportAccess().getUriImportParserRuleCall_0()); }
		ruleUriImport
		{ after(grammarAccess.getImportAccess().getUriImportParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getImportAccess().getNamespaceImportParserRuleCall_1()); }
		ruleNamespaceImport
		{ after(grammarAccess.getImportAccess().getNamespaceImportParserRuleCall_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); }
		(rule__AssertionOrDefinition__Group_1_0__0)
		{ after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); }
		(rule__AssertionOrDefinition__Group_1_1__0)
		{ after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_1()); }
	)
	|
	(
		{ before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); }
		(rule__AssertionOrDefinition__Group_1_2__0)
		{ after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Alternatives_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); }
		(rule__PredicateDefinition__Group_0_0__0)
		{ after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); }
		(rule__PredicateDefinition__Group_0_1__0)
		{ after(grammarAccess.getPredicateDefinitionAccess().getGroup_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDeclaration__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternDeclarationAccess().getExternPredicateDeclarationParserRuleCall_0()); }
		ruleExternPredicateDeclaration
		{ after(grammarAccess.getExternDeclarationAccess().getExternPredicateDeclarationParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getExternDeclarationAccess().getExternFunctionDeclarationParserRuleCall_1()); }
		ruleExternFunctionDeclaration
		{ after(grammarAccess.getExternDeclarationAccess().getExternFunctionDeclarationParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getExternDeclarationAccess().getExternAggregationOperatorDeclarationParserRuleCall_2()); }
		ruleExternAggregationOperatorDeclaration
		{ after(grammarAccess.getExternDeclarationAccess().getExternAggregationOperatorDeclarationParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getExternDeclarationAccess().getExternDatatypeDeclarationParserRuleCall_3()); }
		ruleExternDatatypeDeclaration
		{ after(grammarAccess.getExternDeclarationAccess().getExternDatatypeDeclarationParserRuleCall_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); }
		ruleConditionalExpression
		{ after(grammarAccess.getExpressionAccess().getConditionalExpressionParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_1()); }
		ruleLetExpression
		{ after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getExpressionAccess().getGroup_2()); }
		(rule__Expression__Group_2__0)
		{ after(grammarAccess.getExpressionAccess().getGroup_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); }
		(rule__DisjunctiveExpression__Group_1_0__0)
		{ after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); }
		(rule__DisjunctiveExpression__Group_1_1__0)
		{ after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getBracedAggregateExpressionParserRuleCall_0()); }
		ruleBracedAggregateExpression
		{ after(grammarAccess.getUnaryExpressionAccess().getBracedAggregateExpressionParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
		(rule__UnaryExpression__Group_1__0)
		{ after(grammarAccess.getUnaryExpressionAccess().getGroup_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BracedAggregateExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBracedAggregateExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
		ruleAtomicExpression
		{ after(grammarAccess.getBracedAggregateExpressionAccess().getAtomicExpressionParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getBracedAggregateExpressionAccess().getAggregationParserRuleCall_1()); }
		ruleAggregation
		{ after(grammarAccess.getBracedAggregateExpressionAccess().getAggregationParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getBracedAggregateExpressionAccess().getCountParserRuleCall_2()); }
		ruleCount
		{ after(grammarAccess.getBracedAggregateExpressionAccess().getCountParserRuleCall_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); }
		ruleReference
		{ after(grammarAccess.getAtomicExpressionAccess().getReferenceParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); }
		ruleCall
		{ after(grammarAccess.getAtomicExpressionAccess().getCallParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); }
		ruleInterval
		{ after(grammarAccess.getAtomicExpressionAccess().getIntervalParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); }
		ruleLiteral
		{ after(grammarAccess.getAtomicExpressionAccess().getLiteralParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getAtomicExpressionAccess().getGroup_4()); }
		(rule__AtomicExpression__Group_4__0)
		{ after(grammarAccess.getAtomicExpressionAccess().getGroup_4()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Argument__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); }
		ruleExpressionArgument
		{ after(grammarAccess.getArgumentAccess().getExpressionArgumentParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); }
		ruleStarArgument
		{ after(grammarAccess.getArgumentAccess().getStarArgumentParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getArgumentAccess().getTypedVariableArgumentParserRuleCall_2()); }
		ruleTypedVariableArgument
		{ after(grammarAccess.getArgumentAccess().getTypedVariableArgumentParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); }
		ruleTypedStarArgument
		{ after(grammarAccess.getArgumentAccess().getTypedStarArgumentParserRuleCall_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__Alternatives_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathComponentAccess().getTransitiveClosureAssignment_2_0()); }
		(rule__PathComponent__TransitiveClosureAssignment_2_0)
		{ after(grammarAccess.getPathComponentAccess().getTransitiveClosureAssignment_2_0()); }
	)
	|
	(
		{ before(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureAssignment_2_1()); }
		(rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1)
		{ after(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureAssignment_2_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Literal__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); }
		ruleLogicLiteral
		{ after(grammarAccess.getLiteralAccess().getLogicLiteralParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_1()); }
		ruleIntLiteral
		{ after(grammarAccess.getLiteralAccess().getIntLiteralParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_2()); }
		ruleRealLiteral
		{ after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_2()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_3()); }
		ruleInfinityLiteral
		{ after(grammarAccess.getLiteralAccess().getInfinityLiteralParserRuleCall_3()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getEmptyLiteralParserRuleCall_4()); }
		ruleEmptyLiteral
		{ after(grammarAccess.getLiteralAccess().getEmptyLiteralParserRuleCall_4()); }
	)
	|
	(
		{ before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_5()); }
		ruleStringLiteral
		{ after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_5()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Alternatives_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); }
		(rule__ClassDeclaration__Group_4_0__0)
		{ after(grammarAccess.getClassDeclarationAccess().getGroup_4_0()); }
	)
	|
	(
		{ before(grammarAccess.getClassDeclarationAccess().getFULL_STOPTerminalRuleCall_4_1()); }
		RULE_FULL_STOP
		{ after(grammarAccess.getClassDeclarationAccess().getFULL_STOPTerminalRuleCall_4_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Alternatives_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldAccess().getContainmentAssignment_0_0()); }
		(rule__Field__ContainmentAssignment_0_0)
		{ after(grammarAccess.getFieldAccess().getContainmentAssignment_0_0()); }
	)
	|
	(
		{ before(grammarAccess.getFieldAccess().getCrossReferenceAssignment_0_1()); }
		(rule__Field__CrossReferenceAssignment_0_1)
		{ after(grammarAccess.getFieldAccess().getCrossReferenceAssignment_0_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Multiplicity__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); }
		ruleUnboundedMultiplicity
		{ after(grammarAccess.getMultiplicityAccess().getUnboundedMultiplicityParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); }
		ruleExactMultiplicity
		{ after(grammarAccess.getMultiplicityAccess().getExactMultiplicityParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); }
		ruleBoundedMultiplicity
		{ after(grammarAccess.getMultiplicityAccess().getBoundedMultiplicityParserRuleCall_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Alternatives_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); }
		(rule__EnumDeclaration__Group_2_0__0)
		{ after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0()); }
	)
	|
	(
		{ before(grammarAccess.getEnumDeclarationAccess().getFULL_STOPTerminalRuleCall_2_1()); }
		RULE_FULL_STOP
		{ after(grammarAccess.getEnumDeclarationAccess().getFULL_STOPTerminalRuleCall_2_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ScopeDeclaration__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getScopeDeclarationAccess().getExactScopeParserRuleCall_0()); }
		ruleExactScope
		{ after(grammarAccess.getScopeDeclarationAccess().getExactScopeParserRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getScopeDeclarationAccess().getBoundedScopeParserRuleCall_1()); }
		ruleBoundedScope
		{ after(grammarAccess.getScopeDeclarationAccess().getBoundedScopeParserRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getScopeDeclarationAccess().getLowerBoundedScopeParserRuleCall_2()); }
		ruleLowerBoundedScope
		{ after(grammarAccess.getScopeDeclarationAccess().getLowerBoundedScopeParserRuleCall_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeAccess().getGroup_1_0()); }
		(rule__BoundedScope__Group_1_0__0)
		{ after(grammarAccess.getBoundedScopeAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getBoundedScopeAccess().getGroup_1_1()); }
		(rule__BoundedScope__Group_1_1__0)
		{ after(grammarAccess.getBoundedScopeAccess().getGroup_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Alternatives_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_0()); }
		(rule__LowerBoundedScope__Group_1_0__0)
		{ after(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_0()); }
	)
	|
	(
		{ before(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_1()); }
		(rule__LowerBoundedScope__Group_1_1__0)
		{ after(grammarAccess.getLowerBoundedScopeAccess().getGroup_1_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UpperMultiplicty__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); }
		RULE_INT
		{ after(grammarAccess.getUpperMultiplictyAccess().getINTTerminalRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); }
		Asterisk
		{ after(grammarAccess.getUpperMultiplictyAccess().getAsteriskKeyword_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedNameSegment__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getQualifiedNameSegmentAccess().getIDTerminalRuleCall_0()); }
		RULE_ID
		{ after(grammarAccess.getQualifiedNameSegmentAccess().getIDTerminalRuleCall_0()); }
	)
	|
	(
		{ before(grammarAccess.getQualifiedNameSegmentAccess().getQUOTED_IDTerminalRuleCall_1()); }
		RULE_QUOTED_ID
		{ after(grammarAccess.getQualifiedNameSegmentAccess().getQUOTED_IDTerminalRuleCall_1()); }
	)
	|
	(
		{ before(grammarAccess.getQualifiedNameSegmentAccess().getObjectKeyword_2()); }
		Object
		{ after(grammarAccess.getQualifiedNameSegmentAccess().getObjectKeyword_2()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AttributeKind__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0()); }
		(Functional)
		{ after(grammarAccess.getAttributeKindAccess().getFUNCTIONALEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1()); }
		(Error)
		{ after(grammarAccess.getAttributeKindAccess().getERROREnumLiteralDeclaration_1()); }
	)
	|
	(
		{ before(grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2()); }
		(Root)
		{ after(grammarAccess.getAttributeKindAccess().getROOTEnumLiteralDeclaration_2()); }
	)
	|
	(
		{ before(grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3()); }
		(Containment)
		{ after(grammarAccess.getAttributeKindAccess().getCONTAINMENTEnumLiteralDeclaration_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonOperator__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0()); }
		(EqualsSignEqualsSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getEQUALSEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1()); }
		(ExclamationMarkEqualsSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getNOT_EQUALSEnumLiteralDeclaration_1()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); }
		(LessThanSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getLESSEnumLiteralDeclaration_2()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3()); }
		(LessThanSignEqualsSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getLESS_EQUALSEnumLiteralDeclaration_3()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); }
		(GreaterThanSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getGREATEREnumLiteralDeclaration_4()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5()); }
		(GreaterThanSignEqualsSign)
		{ after(grammarAccess.getComparisonOperatorAccess().getGREATER_EQUALSEnumLiteralDeclaration_5()); }
	)
	|
	(
		{ before(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); }
		(In)
		{ after(grammarAccess.getComparisonOperatorAccess().getINEnumLiteralDeclaration_6()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveBinaryOperator__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0()); }
		(PlusSign)
		{ after(grammarAccess.getAdditiveBinaryOperatorAccess().getPLUSEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1()); }
		(HyphenMinus)
		{ after(grammarAccess.getAdditiveBinaryOperatorAccess().getMINUSEnumLiteralDeclaration_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeBinaryOperator__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0()); }
		(Asterisk)
		{ after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getMULTIPLYEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1()); }
		(Solidus)
		{ after(grammarAccess.getMultiplicativeBinaryOperatorAccess().getDIVIDEEnumLiteralDeclaration_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryOperator__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0()); }
		(ExclamationMark)
		{ after(grammarAccess.getUnaryOperatorAccess().getNOTEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1()); }
		(PlusSign)
		{ after(grammarAccess.getUnaryOperatorAccess().getPLUSEnumLiteralDeclaration_1()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2()); }
		(HyphenMinus)
		{ after(grammarAccess.getUnaryOperatorAccess().getMINUSEnumLiteralDeclaration_2()); }
	)
	|
	(
		{ before(grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3()); }
		(QuestionMark)
		{ after(grammarAccess.getUnaryOperatorAccess().getMAYBEEnumLiteralDeclaration_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicValue__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); }
		(True)
		{ after(grammarAccess.getLogicValueAccess().getTRUEEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); }
		(False)
		{ after(grammarAccess.getLogicValueAccess().getFALSEEnumLiteralDeclaration_1()); }
	)
	|
	(
		{ before(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); }
		(Unknown)
		{ after(grammarAccess.getLogicValueAccess().getUNKNOWNEnumLiteralDeclaration_2()); }
	)
	|
	(
		{ before(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); }
		(Error)
		{ after(grammarAccess.getLogicValueAccess().getERROREnumLiteralDeclaration_3()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveKind__Alternatives
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0()); }
		(Minimize)
		{ after(grammarAccess.getObjectiveKindAccess().getMINIMIZATIONEnumLiteralDeclaration_0()); }
	)
	|
	(
		{ before(grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1()); }
		(Maximize)
		{ after(grammarAccess.getObjectiveKindAccess().getMAXIMIZATIONEnumLiteralDeclaration_1()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Problem__Group__0__Impl
	rule__Problem__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProblemAccess().getGroup_0()); }
	(rule__Problem__Group_0__0)?
	{ after(grammarAccess.getProblemAccess().getGroup_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Problem__Group__1__Impl
	rule__Problem__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProblemAccess().getImportsAssignment_1()); }
	(rule__Problem__ImportsAssignment_1)*
	{ after(grammarAccess.getProblemAccess().getImportsAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Problem__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProblemAccess().getStatementsAssignment_2()); }
	(rule__Problem__StatementsAssignment_2)*
	{ after(grammarAccess.getProblemAccess().getStatementsAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Problem__Group_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Problem__Group_0__0__Impl
	rule__Problem__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); }
	Problem
	{ after(grammarAccess.getProblemAccess().getProblemKeyword_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Problem__Group_0__1__Impl
	rule__Problem__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProblemAccess().getNameAssignment_0_1()); }
	(rule__Problem__NameAssignment_0_1)
	{ after(grammarAccess.getProblemAccess().getNameAssignment_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Problem__Group_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__Group_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getProblemAccess().getFULL_STOPTerminalRuleCall_0_2()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getProblemAccess().getFULL_STOPTerminalRuleCall_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UriImport__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UriImport__Group__0__Impl
	rule__UriImport__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUriImportAccess().getImportKeyword_0()); }
	Import
	{ after(grammarAccess.getUriImportAccess().getImportKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UriImport__Group__1__Impl
	rule__UriImport__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUriImportAccess().getUriAssignment_1()); }
	(rule__UriImport__UriAssignment_1)
	{ after(grammarAccess.getUriImportAccess().getUriAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UriImport__Group__2__Impl
	rule__UriImport__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUriImportAccess().getGroup_2()); }
	(rule__UriImport__Group_2__0)
	{ after(grammarAccess.getUriImportAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UriImport__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUriImportAccess().getFULL_STOPTerminalRuleCall_3()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getUriImportAccess().getFULL_STOPTerminalRuleCall_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UriImport__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UriImport__Group_2__0__Impl
	rule__UriImport__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUriImportAccess().getAsKeyword_2_0()); }
	As
	{ after(grammarAccess.getUriImportAccess().getAsKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UriImport__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUriImportAccess().getAliasAssignment_2_1()); }
	(rule__UriImport__AliasAssignment_2_1)
	{ after(grammarAccess.getUriImportAccess().getAliasAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__NamespaceImport__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NamespaceImport__Group__0__Impl
	rule__NamespaceImport__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNamespaceImportAccess().getImportKeyword_0()); }
	Import
	{ after(grammarAccess.getNamespaceImportAccess().getImportKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NamespaceImport__Group__1__Impl
	rule__NamespaceImport__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNamespaceImportAccess().getImportedNamespaceAssignment_1()); }
	(rule__NamespaceImport__ImportedNamespaceAssignment_1)
	{ after(grammarAccess.getNamespaceImportAccess().getImportedNamespaceAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NamespaceImport__Group__2__Impl
	rule__NamespaceImport__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNamespaceImportAccess().getGroup_2()); }
	(rule__NamespaceImport__Group_2__0)
	{ after(grammarAccess.getNamespaceImportAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NamespaceImport__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNamespaceImportAccess().getFULL_STOPTerminalRuleCall_3()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getNamespaceImportAccess().getFULL_STOPTerminalRuleCall_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__NamespaceImport__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NamespaceImport__Group_2__0__Impl
	rule__NamespaceImport__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNamespaceImportAccess().getAsKeyword_2_0()); }
	As
	{ after(grammarAccess.getNamespaceImportAccess().getAsKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__NamespaceImport__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getNamespaceImportAccess().getAliasAssignment_2_1()); }
	(rule__NamespaceImport__AliasAssignment_2_1)
	{ after(grammarAccess.getNamespaceImportAccess().getAliasAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AssertionOrDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group__0__Impl
	rule__AssertionOrDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); }
	ruleExpression
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group__1__Impl
	rule__AssertionOrDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); }
	(rule__AssertionOrDefinition__Alternatives_1)
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getFULL_STOPTerminalRuleCall_2()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getFULL_STOPTerminalRuleCall_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AssertionOrDefinition__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_0__0__Impl
	rule__AssertionOrDefinition__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getAssertionExpressionAction_1_0_0()); }
	()
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getAssertionExpressionAction_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); }
	(rule__AssertionOrDefinition__Group_1_0_1__0)?
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getGroup_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AssertionOrDefinition__Group_1_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_0_1__0__Impl
	rule__AssertionOrDefinition__Group_1_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); }
	Colon
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getColonKeyword_1_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); }
	(rule__AssertionOrDefinition__RangeAssignment_1_0_1_1)
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getRangeAssignment_1_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AssertionOrDefinition__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_1__0__Impl
	rule__AssertionOrDefinition__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); }
	()
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_1__1__Impl
	rule__AssertionOrDefinition__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); }
	ColonHyphenMinus
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getColonHyphenMinusKeyword_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); }
	(rule__AssertionOrDefinition__BodyAssignment_1_1_2)
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AssertionOrDefinition__Group_1_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_2__0__Impl
	rule__AssertionOrDefinition__Group_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0()); }
	()
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getFunctionDefinitionHeadAction_1_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_2__1__Impl
	rule__AssertionOrDefinition__Group_1_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getColonEqualsSignKeyword_1_2_1()); }
	ColonEqualsSign
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getColonEqualsSignKeyword_1_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_2__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AssertionOrDefinition__Group_1_2__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__Group_1_2__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); }
	(rule__AssertionOrDefinition__BodyAssignment_1_2_2)
	{ after(grammarAccess.getAssertionOrDefinitionAccess().getBodyAssignment_1_2_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PredicateDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group__0__Impl
	rule__PredicateDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); }
	(rule__PredicateDefinition__Alternatives_0)
	{ after(grammarAccess.getPredicateDefinitionAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group__1__Impl
	rule__PredicateDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); }
	(rule__PredicateDefinition__HeadAssignment_1)
	{ after(grammarAccess.getPredicateDefinitionAccess().getHeadAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group__2__Impl
	rule__PredicateDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
	ColonHyphenMinus
	{ after(grammarAccess.getPredicateDefinitionAccess().getColonHyphenMinusKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group__3__Impl
	rule__PredicateDefinition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); }
	(rule__PredicateDefinition__BodyAssignment_3)
	{ after(grammarAccess.getPredicateDefinitionAccess().getBodyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getPredicateDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PredicateDefinition__Group_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group_0_0__0__Impl
	rule__PredicateDefinition__Group_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); }
	(rule__PredicateDefinition__FunctionalAssignment_0_0_0)
	{ after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); }
	(rule__PredicateDefinition__ErrorAssignment_0_0_1)?
	{ after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PredicateDefinition__Group_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group_0_1__0__Impl
	rule__PredicateDefinition__Group_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); }
	(rule__PredicateDefinition__ErrorAssignment_0_1_0)
	{ after(grammarAccess.getPredicateDefinitionAccess().getErrorAssignment_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PredicateDefinition__Group_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__Group_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); }
	(rule__PredicateDefinition__FunctionalAssignment_0_1_1)?
	{ after(grammarAccess.getPredicateDefinitionAccess().getFunctionalAssignment_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnnamedErrorPredicateDefintion__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPredicateDefintion__Group__0__Impl
	rule__UnnamedErrorPredicateDefintion__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getErrorKeyword_0()); }
	Error
	{ after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getErrorKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPredicateDefintion__Group__1__Impl
	rule__UnnamedErrorPredicateDefintion__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListAssignment_1()); }
	(rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1)
	{ after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPredicateDefintion__Group__2__Impl
	rule__UnnamedErrorPredicateDefintion__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getColonHyphenMinusKeyword_2()); }
	ColonHyphenMinus
	{ after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getColonHyphenMinusKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPredicateDefintion__Group__3__Impl
	rule__UnnamedErrorPredicateDefintion__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyAssignment_3()); }
	(rule__UnnamedErrorPredicateDefintion__BodyAssignment_3)
	{ after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnnamedErrorPredicateDefintion__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getFULL_STOPTerminalRuleCall_4()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getFULL_STOPTerminalRuleCall_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DefaultAssertion__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultAssertion__Group__0__Impl
	rule__DefaultAssertion__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultAssertionAccess().getDefaultKeyword_0()); }
	Default
	{ after(grammarAccess.getDefaultAssertionAccess().getDefaultKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultAssertion__Group__1__Impl
	rule__DefaultAssertion__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultAssertionAccess().getExpressionAssignment_1()); }
	(rule__DefaultAssertion__ExpressionAssignment_1)
	{ after(grammarAccess.getDefaultAssertionAccess().getExpressionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultAssertion__Group__2__Impl
	rule__DefaultAssertion__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultAssertionAccess().getGroup_2()); }
	(rule__DefaultAssertion__Group_2__0)?
	{ after(grammarAccess.getDefaultAssertionAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultAssertion__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultAssertionAccess().getFULL_STOPTerminalRuleCall_3()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getDefaultAssertionAccess().getFULL_STOPTerminalRuleCall_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DefaultAssertion__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultAssertion__Group_2__0__Impl
	rule__DefaultAssertion__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultAssertionAccess().getColonKeyword_2_0()); }
	Colon
	{ after(grammarAccess.getDefaultAssertionAccess().getColonKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DefaultAssertion__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDefaultAssertionAccess().getRangeAssignment_2_1()); }
	(rule__DefaultAssertion__RangeAssignment_2_1)
	{ after(grammarAccess.getDefaultAssertionAccess().getRangeAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__FunctionDefinition__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDefinition__Group__0__Impl
	rule__FunctionDefinition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDefinitionAccess().getResultTypeAssignment_0()); }
	(rule__FunctionDefinition__ResultTypeAssignment_0)
	{ after(grammarAccess.getFunctionDefinitionAccess().getResultTypeAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDefinition__Group__1__Impl
	rule__FunctionDefinition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDefinitionAccess().getHeadAssignment_1()); }
	(rule__FunctionDefinition__HeadAssignment_1)
	{ after(grammarAccess.getFunctionDefinitionAccess().getHeadAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDefinition__Group__2__Impl
	rule__FunctionDefinition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDefinitionAccess().getColonEqualsSignKeyword_2()); }
	ColonEqualsSign
	{ after(grammarAccess.getFunctionDefinitionAccess().getColonEqualsSignKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDefinition__Group__3__Impl
	rule__FunctionDefinition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDefinitionAccess().getBodyAssignment_3()); }
	(rule__FunctionDefinition__BodyAssignment_3)
	{ after(grammarAccess.getFunctionDefinitionAccess().getBodyAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__FunctionDefinition__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFunctionDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getFunctionDefinitionAccess().getFULL_STOPTerminalRuleCall_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TypeReference__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypeReference__Group__0__Impl
	rule__TypeReference__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeReference__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypeReferenceAccess().getTypeAssignment_0()); }
	(rule__TypeReference__TypeAssignment_0)
	{ after(grammarAccess.getTypeReferenceAccess().getTypeAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeReference__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypeReference__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeReference__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeAssignment_1()); }
	(rule__TypeReference__ForceObjectTypeAssignment_1)?
	{ after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Attribute__Group__0__Impl
	rule__Attribute__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAttributeAccess().getKindAssignment_0()); }
	(rule__Attribute__KindAssignment_0)
	{ after(grammarAccess.getAttributeAccess().getKindAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Attribute__Group__1__Impl
	rule__Attribute__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAttributeAccess().getTargetAssignment_1()); }
	(rule__Attribute__TargetAssignment_1)
	{ after(grammarAccess.getAttributeAccess().getTargetAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Attribute__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAttributeAccess().getFULL_STOPTerminalRuleCall_2()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getAttributeAccess().getFULL_STOPTerminalRuleCall_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternPredicateDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDeclaration__Group__0__Impl
	rule__ExternPredicateDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternPredicateDeclarationAccess().getExternKeyword_0()); }
	Extern
	{ after(grammarAccess.getExternPredicateDeclarationAccess().getExternKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDeclaration__Group__1__Impl
	rule__ExternPredicateDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); }
	(rule__ExternPredicateDeclaration__UnorderedGroup_1)
	{ after(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDeclaration__Group__2__Impl
	rule__ExternPredicateDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternPredicateDeclarationAccess().getNameAssignment_2()); }
	(rule__ExternPredicateDeclaration__NameAssignment_2)
	{ after(grammarAccess.getExternPredicateDeclarationAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDeclaration__Group__3__Impl
	rule__ExternPredicateDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListAssignment_3()); }
	(rule__ExternPredicateDeclaration__ArgumentListAssignment_3)
	{ after(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDeclaration__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternPredicateDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getExternPredicateDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternFunctionDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternFunctionDeclaration__Group__0__Impl
	rule__ExternFunctionDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternFunctionDeclarationAccess().getExternKeyword_0()); }
	Extern
	{ after(grammarAccess.getExternFunctionDeclarationAccess().getExternKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternFunctionDeclaration__Group__1__Impl
	rule__ExternFunctionDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeAssignment_1()); }
	(rule__ExternFunctionDeclaration__ResultTypeAssignment_1)
	{ after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternFunctionDeclaration__Group__2__Impl
	rule__ExternFunctionDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternFunctionDeclarationAccess().getNameAssignment_2()); }
	(rule__ExternFunctionDeclaration__NameAssignment_2)
	{ after(grammarAccess.getExternFunctionDeclarationAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternFunctionDeclaration__Group__3__Impl
	rule__ExternFunctionDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListAssignment_3()); }
	(rule__ExternFunctionDeclaration__ArgumentListAssignment_3)
	{ after(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternFunctionDeclaration__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternFunctionDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getExternFunctionDeclarationAccess().getFULL_STOPTerminalRuleCall_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternAggregationOperatorDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregationOperatorDeclaration__Group__0__Impl
	rule__ExternAggregationOperatorDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getExternKeyword_0()); }
	Extern
	{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getExternKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregationOperatorDeclaration__Group__1__Impl
	rule__ExternAggregationOperatorDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeAssignment_1()); }
	(rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1)
	{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregationOperatorDeclaration__Group__2__Impl
	rule__ExternAggregationOperatorDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameAssignment_2()); }
	(rule__ExternAggregationOperatorDeclaration__NameAssignment_2)
	{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregationOperatorDeclaration__Group__3__Impl
	rule__ExternAggregationOperatorDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getLeftCurlyBracketKeyword_3()); }
	LeftCurlyBracket
	{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getLeftCurlyBracketKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregationOperatorDeclaration__Group__4__Impl
	rule__ExternAggregationOperatorDeclaration__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeAssignment_4()); }
	(rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4)
	{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregationOperatorDeclaration__Group__5__Impl
	rule__ExternAggregationOperatorDeclaration__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFullStopFullStopFullStopKeyword_5()); }
	FullStopFullStopFullStop
	{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFullStopFullStopFullStopKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__6
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregationOperatorDeclaration__Group__6__Impl
	rule__ExternAggregationOperatorDeclaration__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__6__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getRightCurlyBracketKeyword_6()); }
	RightCurlyBracket
	{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getRightCurlyBracketKeyword_6()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__7
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternAggregationOperatorDeclaration__Group__7__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__Group__7__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFULL_STOPTerminalRuleCall_7()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getFULL_STOPTerminalRuleCall_7()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternDatatypeDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDeclaration__Group__0__Impl
	rule__ExternDatatypeDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDeclarationAccess().getExternKeyword_0()); }
	Extern
	{ after(grammarAccess.getExternDatatypeDeclarationAccess().getExternKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDeclaration__Group__1__Impl
	rule__ExternDatatypeDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDeclarationAccess().getDatatypeKeyword_1()); }
	Datatype
	{ after(grammarAccess.getExternDatatypeDeclarationAccess().getDatatypeKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDeclaration__Group__2__Impl
	rule__ExternDatatypeDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDeclarationAccess().getNameAssignment_2()); }
	(rule__ExternDatatypeDeclaration__NameAssignment_2)
	{ after(grammarAccess.getExternDatatypeDeclarationAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternDatatypeDeclaration__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExternDatatypeDeclarationAccess().getFULL_STOPTerminalRuleCall_3()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getExternDatatypeDeclarationAccess().getFULL_STOPTerminalRuleCall_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Expression__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Expression__Group_2__0__Impl
	rule__Expression__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_2_0()); }
	ruleDisjunctiveExpression
	{ after(grammarAccess.getExpressionAccess().getDisjunctiveExpressionParserRuleCall_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Expression__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExpressionAccess().getGroup_2_1()); }
	(rule__Expression__Group_2_1__0)?
	{ after(grammarAccess.getExpressionAccess().getGroup_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Expression__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Expression__Group_2_1__0__Impl
	rule__Expression__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0()); }
	()
	{ after(grammarAccess.getExpressionAccess().getForallConditionAction_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Expression__Group_2_1__1__Impl
	rule__Expression__Group_2_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExpressionAccess().getEqualsSignGreaterThanSignKeyword_2_1_1()); }
	EqualsSignGreaterThanSign
	{ after(grammarAccess.getExpressionAccess().getEqualsSignGreaterThanSignKeyword_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Group_2_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Expression__Group_2_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__Group_2_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExpressionAccess().getBodyAssignment_2_1_2()); }
	(rule__Expression__BodyAssignment_2_1_2)
	{ after(grammarAccess.getExpressionAccess().getBodyAssignment_2_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ConditionalExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalExpression__Group__0__Impl
	rule__ConditionalExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalExpressionAccess().getIfKeyword_0()); }
	If
	{ after(grammarAccess.getConditionalExpressionAccess().getIfKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalExpression__Group__1__Impl
	rule__ConditionalExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalExpressionAccess().getConditionAssignment_1()); }
	(rule__ConditionalExpression__ConditionAssignment_1)
	{ after(grammarAccess.getConditionalExpressionAccess().getConditionAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalExpression__Group__2__Impl
	rule__ConditionalExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalExpressionAccess().getThenKeyword_2()); }
	Then
	{ after(grammarAccess.getConditionalExpressionAccess().getThenKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalExpression__Group__3__Impl
	rule__ConditionalExpression__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalExpressionAccess().getThenAssignment_3()); }
	(rule__ConditionalExpression__ThenAssignment_3)
	{ after(grammarAccess.getConditionalExpressionAccess().getThenAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalExpression__Group__4__Impl
	rule__ConditionalExpression__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalExpressionAccess().getElseKeyword_4()); }
	Else
	{ after(grammarAccess.getConditionalExpressionAccess().getElseKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConditionalExpression__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConditionalExpressionAccess().getElseAssignment_5()); }
	(rule__ConditionalExpression__ElseAssignment_5)
	{ after(grammarAccess.getConditionalExpressionAccess().getElseAssignment_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LetExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetExpression__Group__0__Impl
	rule__LetExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); }
	Let
	{ after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetExpression__Group__1__Impl
	rule__LetExpression__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetExpressionAccess().getBindingsAssignment_1()); }
	(rule__LetExpression__BindingsAssignment_1)
	{ after(grammarAccess.getLetExpressionAccess().getBindingsAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetExpression__Group__2__Impl
	rule__LetExpression__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetExpressionAccess().getGroup_2()); }
	(rule__LetExpression__Group_2__0)*
	{ after(grammarAccess.getLetExpressionAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetExpression__Group__3__Impl
	rule__LetExpression__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetExpressionAccess().getInKeyword_3()); }
	In
	{ after(grammarAccess.getLetExpressionAccess().getInKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetExpression__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetExpressionAccess().getBodyAssignment_4()); }
	(rule__LetExpression__BodyAssignment_4)
	{ after(grammarAccess.getLetExpressionAccess().getBodyAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LetExpression__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetExpression__Group_2__0__Impl
	rule__LetExpression__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); }
	Comma
	{ after(grammarAccess.getLetExpressionAccess().getCommaKeyword_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetExpression__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetExpressionAccess().getBindingsAssignment_2_1()); }
	(rule__LetExpression__BindingsAssignment_2_1)
	{ after(grammarAccess.getLetExpressionAccess().getBindingsAssignment_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LetBinding__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetBinding__Group__0__Impl
	rule__LetBinding__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetBindingAccess().getTypeAssignment_0()); }
	(rule__LetBinding__TypeAssignment_0)?
	{ after(grammarAccess.getLetBindingAccess().getTypeAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetBinding__Group__1__Impl
	rule__LetBinding__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetBindingAccess().getNameAssignment_1()); }
	(rule__LetBinding__NameAssignment_1)
	{ after(grammarAccess.getLetBindingAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetBinding__Group__2__Impl
	rule__LetBinding__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_2()); }
	EqualsSign
	{ after(grammarAccess.getLetBindingAccess().getEqualsSignKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LetBinding__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLetBindingAccess().getValueAssignment_3()); }
	(rule__LetBinding__ValueAssignment_3)
	{ after(grammarAccess.getLetBindingAccess().getValueAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DisjunctiveExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group__0__Impl
	rule__DisjunctiveExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); }
	ruleConjunctiveExpression
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getConjunctiveExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); }
	(rule__DisjunctiveExpression__Alternatives_1)?
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DisjunctiveExpression__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_0__0__Impl
	rule__DisjunctiveExpression__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); }
	()
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getDisjunctionChildrenAction_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	(
		{ before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
		(rule__DisjunctiveExpression__Group_1_0_1__0)
		{ after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
	)
	(
		{ before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
		(rule__DisjunctiveExpression__Group_1_0_1__0)*
		{ after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_0_1()); }
	)
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DisjunctiveExpression__Group_1_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_0_1__0__Impl
	rule__DisjunctiveExpression__Group_1_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); }
	Semicolon
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); }
	(rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1)
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenAssignment_1_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DisjunctiveExpression__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_1__0__Impl
	rule__DisjunctiveExpression__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); }
	()
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_1__1__Impl
	rule__DisjunctiveExpression__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); }
	HyphenMinusGreaterThanSign
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_1__2__Impl
	rule__DisjunctiveExpression__Group_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); }
	(rule__DisjunctiveExpression__BodyAssignment_1_1_2)
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getBodyAssignment_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_1__3__Impl
	rule__DisjunctiveExpression__Group_1_1__4
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); }
	()
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_1__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); }
	(rule__DisjunctiveExpression__Group_1_1_4__0)*
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getGroup_1_1_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__DisjunctiveExpression__Group_1_1_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_1_4__0__Impl
	rule__DisjunctiveExpression__Group_1_1_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); }
	Semicolon
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getSemicolonKeyword_1_1_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__DisjunctiveExpression__Group_1_1_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__Group_1_1_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); }
	(rule__DisjunctiveExpression__CasesAssignment_1_1_4_1)
	{ after(grammarAccess.getDisjunctiveExpressionAccess().getCasesAssignment_1_1_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Case__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Case__Group__0__Impl
	rule__Case__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Case__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseAccess().getConditionAssignment_0()); }
	(rule__Case__ConditionAssignment_0)
	{ after(grammarAccess.getCaseAccess().getConditionAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Case__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Case__Group__1__Impl
	rule__Case__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Case__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); }
	HyphenMinusGreaterThanSign
	{ after(grammarAccess.getCaseAccess().getHyphenMinusGreaterThanSignKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Case__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Case__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Case__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCaseAccess().getBodyAssignment_2()); }
	(rule__Case__BodyAssignment_2)
	{ after(grammarAccess.getCaseAccess().getBodyAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ConjunctiveExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConjunctiveExpression__Group__0__Impl
	rule__ConjunctiveExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); }
	ruleComparisonExpression
	{ after(grammarAccess.getConjunctiveExpressionAccess().getComparisonExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConjunctiveExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); }
	(rule__ConjunctiveExpression__Group_1__0)?
	{ after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ConjunctiveExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConjunctiveExpression__Group_1__0__Impl
	rule__ConjunctiveExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); }
	()
	{ after(grammarAccess.getConjunctiveExpressionAccess().getConjunctionChildrenAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConjunctiveExpression__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	(
		{ before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
		(rule__ConjunctiveExpression__Group_1_1__0)
		{ after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
	)
	(
		{ before(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
		(rule__ConjunctiveExpression__Group_1_1__0)*
		{ after(grammarAccess.getConjunctiveExpressionAccess().getGroup_1_1()); }
	)
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ConjunctiveExpression__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConjunctiveExpression__Group_1_1__0__Impl
	rule__ConjunctiveExpression__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); }
	Comma
	{ after(grammarAccess.getConjunctiveExpressionAccess().getCommaKeyword_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ConjunctiveExpression__Group_1_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); }
	(rule__ConjunctiveExpression__ChildrenAssignment_1_1_1)
	{ after(grammarAccess.getConjunctiveExpressionAccess().getChildrenAssignment_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComparisonExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComparisonExpression__Group__0__Impl
	rule__ComparisonExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); }
	ruleAdditiveExpression
	{ after(grammarAccess.getComparisonExpressionAccess().getAdditiveExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComparisonExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonExpressionAccess().getGroup_1()); }
	(rule__ComparisonExpression__Group_1__0)?
	{ after(grammarAccess.getComparisonExpressionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ComparisonExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComparisonExpression__Group_1__0__Impl
	rule__ComparisonExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getComparisonExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComparisonExpression__Group_1__1__Impl
	rule__ComparisonExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); }
	(rule__ComparisonExpression__OpAssignment_1_1)
	{ after(grammarAccess.getComparisonExpressionAccess().getOpAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ComparisonExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); }
	(rule__ComparisonExpression__RightAssignment_1_2)
	{ after(grammarAccess.getComparisonExpressionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AdditiveExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AdditiveExpression__Group__0__Impl
	rule__AdditiveExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); }
	ruleMultiplicativeExpression
	{ after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AdditiveExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); }
	(rule__AdditiveExpression__Group_1__0)*
	{ after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AdditiveExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AdditiveExpression__Group_1__0__Impl
	rule__AdditiveExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getAdditiveExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AdditiveExpression__Group_1__1__Impl
	rule__AdditiveExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); }
	(rule__AdditiveExpression__OpAssignment_1_1)
	{ after(grammarAccess.getAdditiveExpressionAccess().getOpAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AdditiveExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); }
	(rule__AdditiveExpression__RightAssignment_1_2)
	{ after(grammarAccess.getAdditiveExpressionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__MultiplicativeExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MultiplicativeExpression__Group__0__Impl
	rule__MultiplicativeExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); }
	ruleExponentialExpression
	{ after(grammarAccess.getMultiplicativeExpressionAccess().getExponentialExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MultiplicativeExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); }
	(rule__MultiplicativeExpression__Group_1__0)*
	{ after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__MultiplicativeExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MultiplicativeExpression__Group_1__0__Impl
	rule__MultiplicativeExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getMultiplicativeExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MultiplicativeExpression__Group_1__1__Impl
	rule__MultiplicativeExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); }
	(rule__MultiplicativeExpression__OpAssignment_1_1)
	{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__MultiplicativeExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); }
	(rule__MultiplicativeExpression__RightAssignment_1_2)
	{ after(grammarAccess.getMultiplicativeExpressionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExponentialExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExponentialExpression__Group__0__Impl
	rule__ExponentialExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExponentialExpressionAccess().getCastExpressionParserRuleCall_0()); }
	ruleCastExpression
	{ after(grammarAccess.getExponentialExpressionAccess().getCastExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExponentialExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExponentialExpressionAccess().getGroup_1()); }
	(rule__ExponentialExpression__Group_1__0)?
	{ after(grammarAccess.getExponentialExpressionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExponentialExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExponentialExpression__Group_1__0__Impl
	rule__ExponentialExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
	()
	{ after(grammarAccess.getExponentialExpressionAccess().getBinaryExpressionLeftAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExponentialExpression__Group_1__1__Impl
	rule__ExponentialExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); }
	(rule__ExponentialExpression__OpAssignment_1_1)
	{ after(grammarAccess.getExponentialExpressionAccess().getOpAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExponentialExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); }
	(rule__ExponentialExpression__RightAssignment_1_2)
	{ after(grammarAccess.getExponentialExpressionAccess().getRightAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__CastExpression__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CastExpression__Group__0__Impl
	rule__CastExpression__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCastExpressionAccess().getUnaryExpressionParserRuleCall_0()); }
	ruleUnaryExpression
	{ after(grammarAccess.getCastExpressionAccess().getUnaryExpressionParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CastExpression__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCastExpressionAccess().getGroup_1()); }
	(rule__CastExpression__Group_1__0)?
	{ after(grammarAccess.getCastExpressionAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__CastExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CastExpression__Group_1__0__Impl
	rule__CastExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0()); }
	()
	{ after(grammarAccess.getCastExpressionAccess().getCastExpressionBodyAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CastExpression__Group_1__1__Impl
	rule__CastExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCastExpressionAccess().getAsKeyword_1_1()); }
	As
	{ after(grammarAccess.getCastExpressionAccess().getAsKeyword_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__CastExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCastExpressionAccess().getTargetTypeAssignment_1_2()); }
	(rule__CastExpression__TargetTypeAssignment_1_2)
	{ after(grammarAccess.getCastExpressionAccess().getTargetTypeAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnaryExpression__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_1__0__Impl
	rule__UnaryExpression__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); }
	()
	{ after(grammarAccess.getUnaryExpressionAccess().getUnaryExpressionAction_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_1__1__Impl
	rule__UnaryExpression__Group_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); }
	(rule__UnaryExpression__OpAssignment_1_1)
	{ after(grammarAccess.getUnaryExpressionAccess().getOpAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnaryExpression__Group_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__Group_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); }
	(rule__UnaryExpression__BodyAssignment_1_2)
	{ after(grammarAccess.getUnaryExpressionAccess().getBodyAssignment_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Aggregation__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Aggregation__Group__0__Impl
	rule__Aggregation__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAggregationAccess().getOpAssignment_0()); }
	(rule__Aggregation__OpAssignment_0)
	{ after(grammarAccess.getAggregationAccess().getOpAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Aggregation__Group__1__Impl
	rule__Aggregation__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); }
	LeftCurlyBracket
	{ after(grammarAccess.getAggregationAccess().getLeftCurlyBracketKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Aggregation__Group__2__Impl
	rule__Aggregation__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAggregationAccess().getValueAssignment_2()); }
	(rule__Aggregation__ValueAssignment_2)
	{ after(grammarAccess.getAggregationAccess().getValueAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Aggregation__Group__3__Impl
	rule__Aggregation__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); }
	VerticalLine
	{ after(grammarAccess.getAggregationAccess().getVerticalLineKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Aggregation__Group__4__Impl
	rule__Aggregation__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAggregationAccess().getConditionAssignment_4()); }
	(rule__Aggregation__ConditionAssignment_4)
	{ after(grammarAccess.getAggregationAccess().getConditionAssignment_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Aggregation__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); }
	RightCurlyBracket
	{ after(grammarAccess.getAggregationAccess().getRightCurlyBracketKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Count__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Count__Group__0__Impl
	rule__Count__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Count__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCountAccess().getCountKeyword_0()); }
	Count
	{ after(grammarAccess.getCountAccess().getCountKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Count__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Count__Group__1__Impl
	rule__Count__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Count__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); }
	LeftCurlyBracket
	{ after(grammarAccess.getCountAccess().getLeftCurlyBracketKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Count__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Count__Group__2__Impl
	rule__Count__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Count__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCountAccess().getConditionAssignment_2()); }
	(rule__Count__ConditionAssignment_2)
	{ after(grammarAccess.getCountAccess().getConditionAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Count__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Count__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Count__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); }
	RightCurlyBracket
	{ after(grammarAccess.getCountAccess().getRightCurlyBracketKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__AtomicExpression__Group_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicExpression__Group_4__0__Impl
	rule__AtomicExpression__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); }
	LeftParenthesis
	{ after(grammarAccess.getAtomicExpressionAccess().getLeftParenthesisKeyword_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicExpression__Group_4__1__Impl
	rule__AtomicExpression__Group_4__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); }
	ruleExpression
	{ after(grammarAccess.getAtomicExpressionAccess().getExpressionParserRuleCall_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_4__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__AtomicExpression__Group_4__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AtomicExpression__Group_4__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); }
	RightParenthesis
	{ after(grammarAccess.getAtomicExpressionAccess().getRightParenthesisKeyword_4_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Call__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Call__Group__0__Impl
	rule__Call__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Call__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCallAccess().getFunctorAssignment_0()); }
	(rule__Call__FunctorAssignment_0)
	{ after(grammarAccess.getCallAccess().getFunctorAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Call__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Call__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Call__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getCallAccess().getArgumentListAssignment_1()); }
	(rule__Call__ArgumentListAssignment_1)
	{ after(grammarAccess.getCallAccess().getArgumentListAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ArgumentList__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArgumentList__Group__0__Impl
	rule__ArgumentList__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); }
	()
	{ after(grammarAccess.getArgumentListAccess().getArgumentListAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArgumentList__Group__1__Impl
	rule__ArgumentList__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); }
	LeftParenthesis
	{ after(grammarAccess.getArgumentListAccess().getLeftParenthesisKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArgumentList__Group__2__Impl
	rule__ArgumentList__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArgumentListAccess().getGroup_2()); }
	(rule__ArgumentList__Group_2__0)?
	{ after(grammarAccess.getArgumentListAccess().getGroup_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArgumentList__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); }
	RightParenthesis
	{ after(grammarAccess.getArgumentListAccess().getRightParenthesisKeyword_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ArgumentList__Group_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArgumentList__Group_2__0__Impl
	rule__ArgumentList__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); }
	(rule__ArgumentList__ArgumentsAssignment_2_0)
	{ after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArgumentList__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArgumentListAccess().getGroup_2_1()); }
	(rule__ArgumentList__Group_2_1__0)*
	{ after(grammarAccess.getArgumentListAccess().getGroup_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ArgumentList__Group_2_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArgumentList__Group_2_1__0__Impl
	rule__ArgumentList__Group_2_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group_2_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); }
	Comma
	{ after(grammarAccess.getArgumentListAccess().getCommaKeyword_2_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group_2_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ArgumentList__Group_2_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__Group_2_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); }
	(rule__ArgumentList__ArgumentsAssignment_2_1_1)
	{ after(grammarAccess.getArgumentListAccess().getArgumentsAssignment_2_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__StarArgument__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StarArgument__Group__0__Impl
	rule__StarArgument__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StarArgument__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); }
	()
	{ after(grammarAccess.getStarArgumentAccess().getStarArgumentAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__StarArgument__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__StarArgument__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StarArgument__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); }
	Asterisk
	{ after(grammarAccess.getStarArgumentAccess().getAsteriskKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TypedVariableArgument__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypedVariableArgument__Group__0__Impl
	rule__TypedVariableArgument__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedVariableArgument__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceAssignment_0()); }
	(rule__TypedVariableArgument__TypeReferenceAssignment_0)
	{ after(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedVariableArgument__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypedVariableArgument__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedVariableArgument__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypedVariableArgumentAccess().getNameAssignment_1()); }
	(rule__TypedVariableArgument__NameAssignment_1)
	{ after(grammarAccess.getTypedVariableArgumentAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__TypedStarArgument__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypedStarArgument__Group__0__Impl
	rule__TypedStarArgument__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedStarArgument__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceAssignment_0()); }
	(rule__TypedStarArgument__TypeReferenceAssignment_0)
	{ after(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedStarArgument__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__TypedStarArgument__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedStarArgument__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); }
	Asterisk
	{ after(grammarAccess.getTypedStarArgumentAccess().getAsteriskKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Reference__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Reference__Group__0__Impl
	rule__Reference__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getReferenceAccess().getComponentsAssignment_0()); }
	(rule__Reference__ComponentsAssignment_0)
	{ after(grammarAccess.getReferenceAccess().getComponentsAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Reference__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getReferenceAccess().getGroup_1()); }
	(rule__Reference__Group_1__0)*
	{ after(grammarAccess.getReferenceAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Reference__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Reference__Group_1__0__Impl
	rule__Reference__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getReferenceAccess().getFullStopKeyword_1_0()); }
	FullStop
	{ after(grammarAccess.getReferenceAccess().getFullStopKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Reference__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getReferenceAccess().getComponentsAssignment_1_1()); }
	(rule__Reference__ComponentsAssignment_1_1)
	{ after(grammarAccess.getReferenceAccess().getComponentsAssignment_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__PathComponent__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PathComponent__Group__0__Impl
	rule__PathComponent__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPathComponentAccess().getInverseAssignment_0()); }
	(rule__PathComponent__InverseAssignment_0)?
	{ after(grammarAccess.getPathComponentAccess().getInverseAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PathComponent__Group__1__Impl
	rule__PathComponent__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPathComponentAccess().getSymbolAssignment_1()); }
	(rule__PathComponent__SymbolAssignment_1)
	{ after(grammarAccess.getPathComponentAccess().getSymbolAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__PathComponent__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getPathComponentAccess().getAlternatives_2()); }
	(rule__PathComponent__Alternatives_2)?
	{ after(grammarAccess.getPathComponentAccess().getAlternatives_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Interval__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Interval__Group__0__Impl
	rule__Interval__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); }
	LeftSquareBracket
	{ after(grammarAccess.getIntervalAccess().getLeftSquareBracketKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Interval__Group__1__Impl
	rule__Interval__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); }
	(rule__Interval__LowerBoundAssignment_1)
	{ after(grammarAccess.getIntervalAccess().getLowerBoundAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Interval__Group__2__Impl
	rule__Interval__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIntervalAccess().getCommaKeyword_2()); }
	Comma
	{ after(grammarAccess.getIntervalAccess().getCommaKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Interval__Group__3__Impl
	rule__Interval__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); }
	(rule__Interval__UpperBoundAssignment_3)
	{ after(grammarAccess.getIntervalAccess().getUpperBoundAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Interval__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); }
	RightSquareBracket
	{ after(grammarAccess.getIntervalAccess().getRightSquareBracketKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__InfinityLiteral__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InfinityLiteral__Group__0__Impl
	rule__InfinityLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InfinityLiteral__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); }
	()
	{ after(grammarAccess.getInfinityLiteralAccess().getInfinityLiteralAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__InfinityLiteral__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__InfinityLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InfinityLiteral__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); }
	Inf
	{ after(grammarAccess.getInfinityLiteralAccess().getInfKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__EmptyLiteral__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EmptyLiteral__Group__0__Impl
	rule__EmptyLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EmptyLiteral__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEmptyLiteralAccess().getEmptyLiteralAction_0()); }
	()
	{ after(grammarAccess.getEmptyLiteralAccess().getEmptyLiteralAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EmptyLiteral__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EmptyLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EmptyLiteral__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEmptyLiteralAccess().getEmptyKeyword_1()); }
	Empty
	{ after(grammarAccess.getEmptyLiteralAccess().getEmptyKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ClassDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group__0__Impl
	rule__ClassDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); }
	(rule__ClassDeclaration__UnorderedGroup_0)
	{ after(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group__1__Impl
	rule__ClassDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); }
	Class
	{ after(grammarAccess.getClassDeclarationAccess().getClassKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group__2__Impl
	rule__ClassDeclaration__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); }
	(rule__ClassDeclaration__NameAssignment_2)
	{ after(grammarAccess.getClassDeclarationAccess().getNameAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group__3__Impl
	rule__ClassDeclaration__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getGroup_3()); }
	(rule__ClassDeclaration__Group_3__0)?
	{ after(grammarAccess.getClassDeclarationAccess().getGroup_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); }
	(rule__ClassDeclaration__Alternatives_4)
	{ after(grammarAccess.getClassDeclarationAccess().getAlternatives_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ClassDeclaration__Group_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group_3__0__Impl
	rule__ClassDeclaration__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); }
	Extends
	{ after(grammarAccess.getClassDeclarationAccess().getExtendsKeyword_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group_3__1__Impl
	rule__ClassDeclaration__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_1()); }
	(rule__ClassDeclaration__SupertypesAssignment_3_1)
	{ after(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_3__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group_3__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_3__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); }
	(rule__ClassDeclaration__Group_3_2__0)*
	{ after(grammarAccess.getClassDeclarationAccess().getGroup_3_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ClassDeclaration__Group_3_2__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group_3_2__0__Impl
	rule__ClassDeclaration__Group_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_3_2__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); }
	Comma
	{ after(grammarAccess.getClassDeclarationAccess().getCommaKeyword_3_2_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_3_2__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group_3_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_3_2__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_2_1()); }
	(rule__ClassDeclaration__SupertypesAssignment_3_2_1)
	{ after(grammarAccess.getClassDeclarationAccess().getSupertypesAssignment_3_2_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ClassDeclaration__Group_4_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group_4_0__0__Impl
	rule__ClassDeclaration__Group_4_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_4_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); }
	LeftCurlyBracket
	{ after(grammarAccess.getClassDeclarationAccess().getLeftCurlyBracketKeyword_4_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_4_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group_4_0__1__Impl
	rule__ClassDeclaration__Group_4_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_4_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getFieldsAssignment_4_0_1()); }
	(rule__ClassDeclaration__FieldsAssignment_4_0_1)*
	{ after(grammarAccess.getClassDeclarationAccess().getFieldsAssignment_4_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_4_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__Group_4_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__Group_4_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); }
	RightCurlyBracket
	{ after(grammarAccess.getClassDeclarationAccess().getRightCurlyBracketKeyword_4_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Field__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Field__Group__0__Impl
	rule__Field__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldAccess().getAlternatives_0()); }
	(rule__Field__Alternatives_0)?
	{ after(grammarAccess.getFieldAccess().getAlternatives_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Field__Group__1__Impl
	rule__Field__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldAccess().getTypeAssignment_1()); }
	(rule__Field__TypeAssignment_1)
	{ after(grammarAccess.getFieldAccess().getTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Field__Group__2__Impl
	rule__Field__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldAccess().getMultiplicityAssignment_2()); }
	(rule__Field__MultiplicityAssignment_2)?
	{ after(grammarAccess.getFieldAccess().getMultiplicityAssignment_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Field__Group__3__Impl
	rule__Field__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldAccess().getNameAssignment_3()); }
	(rule__Field__NameAssignment_3)
	{ after(grammarAccess.getFieldAccess().getNameAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Field__Group__4__Impl
	rule__Field__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldAccess().getGroup_4()); }
	(rule__Field__Group_4__0)?
	{ after(grammarAccess.getFieldAccess().getGroup_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__5
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Field__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group__5__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldAccess().getSemicolonKeyword_5()); }
	(Semicolon)?
	{ after(grammarAccess.getFieldAccess().getSemicolonKeyword_5()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Field__Group_4__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Field__Group_4__0__Impl
	rule__Field__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group_4__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldAccess().getOppositeKeyword_4_0()); }
	Opposite
	{ after(grammarAccess.getFieldAccess().getOppositeKeyword_4_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group_4__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Field__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__Group_4__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getFieldAccess().getOppositeAssignment_4_1()); }
	(rule__Field__OppositeAssignment_4_1)
	{ after(grammarAccess.getFieldAccess().getOppositeAssignment_4_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__UnboundedMultiplicity__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnboundedMultiplicity__Group__0__Impl
	rule__UnboundedMultiplicity__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UnboundedMultiplicity__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction_0()); }
	()
	{ after(grammarAccess.getUnboundedMultiplicityAccess().getUnboundedMultiplicityAction_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnboundedMultiplicity__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnboundedMultiplicity__Group__1__Impl
	rule__UnboundedMultiplicity__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UnboundedMultiplicity__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnboundedMultiplicityAccess().getLeftSquareBracketKeyword_1()); }
	LeftSquareBracket
	{ after(grammarAccess.getUnboundedMultiplicityAccess().getLeftSquareBracketKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnboundedMultiplicity__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__UnboundedMultiplicity__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UnboundedMultiplicity__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getUnboundedMultiplicityAccess().getRightSquareBracketKeyword_2()); }
	RightSquareBracket
	{ after(grammarAccess.getUnboundedMultiplicityAccess().getRightSquareBracketKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExactMultiplicity__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactMultiplicity__Group__0__Impl
	rule__ExactMultiplicity__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactMultiplicity__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
	LeftSquareBracket
	{ after(grammarAccess.getExactMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactMultiplicity__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactMultiplicity__Group__1__Impl
	rule__ExactMultiplicity__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactMultiplicity__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactMultiplicityAccess().getValueAssignment_1()); }
	(rule__ExactMultiplicity__ValueAssignment_1)
	{ after(grammarAccess.getExactMultiplicityAccess().getValueAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactMultiplicity__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactMultiplicity__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactMultiplicity__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); }
	RightSquareBracket
	{ after(grammarAccess.getExactMultiplicityAccess().getRightSquareBracketKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedMultiplicity__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedMultiplicity__Group__0__Impl
	rule__BoundedMultiplicity__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
	LeftSquareBracket
	{ after(grammarAccess.getBoundedMultiplicityAccess().getLeftSquareBracketKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedMultiplicity__Group__1__Impl
	rule__BoundedMultiplicity__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); }
	(rule__BoundedMultiplicity__LowerBoundAssignment_1)
	{ after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedMultiplicity__Group__2__Impl
	rule__BoundedMultiplicity__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedMultiplicityAccess().getCommaKeyword_2()); }
	Comma
	{ after(grammarAccess.getBoundedMultiplicityAccess().getCommaKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedMultiplicity__Group__3__Impl
	rule__BoundedMultiplicity__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); }
	(rule__BoundedMultiplicity__UpperBoundAssignment_3)
	{ after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedMultiplicity__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); }
	RightSquareBracket
	{ after(grammarAccess.getBoundedMultiplicityAccess().getRightSquareBracketKeyword_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__EnumDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group__0__Impl
	rule__EnumDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); }
	Enum
	{ after(grammarAccess.getEnumDeclarationAccess().getEnumKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group__1__Impl
	rule__EnumDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); }
	(rule__EnumDeclaration__NameAssignment_1)
	{ after(grammarAccess.getEnumDeclarationAccess().getNameAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); }
	(rule__EnumDeclaration__Alternatives_2)
	{ after(grammarAccess.getEnumDeclarationAccess().getAlternatives_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__EnumDeclaration__Group_2_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group_2_0__0__Impl
	rule__EnumDeclaration__Group_2_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); }
	LeftCurlyBracket
	{ after(grammarAccess.getEnumDeclarationAccess().getLeftCurlyBracketKeyword_2_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group_2_0__1__Impl
	rule__EnumDeclaration__Group_2_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); }
	(rule__EnumDeclaration__Group_2_0_1__0)?
	{ after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group_2_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); }
	RightCurlyBracket
	{ after(grammarAccess.getEnumDeclarationAccess().getRightCurlyBracketKeyword_2_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__EnumDeclaration__Group_2_0_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group_2_0_1__0__Impl
	rule__EnumDeclaration__Group_2_0_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); }
	(rule__EnumDeclaration__LiteralsAssignment_2_0_1_0)
	{ after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group_2_0_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); }
	(rule__EnumDeclaration__Group_2_0_1_1__0)*
	{ after(grammarAccess.getEnumDeclarationAccess().getGroup_2_0_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__EnumDeclaration__Group_2_0_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group_2_0_1_1__0__Impl
	rule__EnumDeclaration__Group_2_0_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); }
	(Comma)?
	{ after(grammarAccess.getEnumDeclarationAccess().getCommaKeyword_2_0_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__EnumDeclaration__Group_2_0_1_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__Group_2_0_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); }
	(rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1)
	{ after(grammarAccess.getEnumDeclarationAccess().getLiteralsAssignment_2_0_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExactScope__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScope__Group__0__Impl
	rule__ExactScope__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactScopeAccess().getScopeKeyword_0()); }
	Scope
	{ after(grammarAccess.getExactScopeAccess().getScopeKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScope__Group__1__Impl
	rule__ExactScope__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactScopeAccess().getTypeAssignment_1()); }
	(rule__ExactScope__TypeAssignment_1)
	{ after(grammarAccess.getExactScopeAccess().getTypeAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScope__Group__2__Impl
	rule__ExactScope__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactScopeAccess().getEqualsSignEqualsSignKeyword_2()); }
	EqualsSignEqualsSign
	{ after(grammarAccess.getExactScopeAccess().getEqualsSignEqualsSignKeyword_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScope__Group__3__Impl
	rule__ExactScope__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactScopeAccess().getSizeAssignment_3()); }
	(rule__ExactScope__SizeAssignment_3)
	{ after(grammarAccess.getExactScopeAccess().getSizeAssignment_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__4
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExactScope__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__Group__4__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getExactScopeAccess().getFULL_STOPTerminalRuleCall_4()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getExactScopeAccess().getFULL_STOPTerminalRuleCall_4()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScope__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group__0__Impl
	rule__BoundedScope__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getScopeKeyword_0()); }
	Scope
	{ after(grammarAccess.getBoundedScopeAccess().getScopeKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group__1__Impl
	rule__BoundedScope__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getAlternatives_1()); }
	(rule__BoundedScope__Alternatives_1)
	{ after(grammarAccess.getBoundedScopeAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScope__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_0__0__Impl
	rule__BoundedScope__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getGroup_1_0_0()); }
	(rule__BoundedScope__Group_1_0_0__0)?
	{ after(grammarAccess.getBoundedScopeAccess().getGroup_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_0__1__Impl
	rule__BoundedScope__Group_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_0_1()); }
	(rule__BoundedScope__TypeAssignment_1_0_1)
	{ after(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_0__2__Impl
	rule__BoundedScope__Group_1_0__3
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_2()); }
	LessThanSignEqualsSign
	{ after(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_0__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_0_3()); }
	(rule__BoundedScope__UpperBoundAssignment_1_0_3)
	{ after(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_0_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScope__Group_1_0_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_0_0__0__Impl
	rule__BoundedScope__Group_1_0_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_0_0_0()); }
	(rule__BoundedScope__LowerBoundAssignment_1_0_0_0)
	{ after(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_0_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_0_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_0_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); }
	LessThanSignEqualsSign
	{ after(grammarAccess.getBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScope__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_1__0__Impl
	rule__BoundedScope__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_1_0()); }
	(rule__BoundedScope__UpperBoundAssignment_1_1_0)
	{ after(grammarAccess.getBoundedScopeAccess().getUpperBoundAssignment_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_1__1__Impl
	rule__BoundedScope__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
	GreaterThanSignEqualsSign
	{ after(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_1__2__Impl
	rule__BoundedScope__Group_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_1_2()); }
	(rule__BoundedScope__TypeAssignment_1_1_2)
	{ after(grammarAccess.getBoundedScopeAccess().getTypeAssignment_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1__3
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1__3__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getGroup_1_1_3()); }
	(rule__BoundedScope__Group_1_1_3__0)?
	{ after(grammarAccess.getBoundedScopeAccess().getGroup_1_1_3()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__BoundedScope__Group_1_1_3__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_1_3__0__Impl
	rule__BoundedScope__Group_1_1_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1_3__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); }
	GreaterThanSignEqualsSign
	{ after(grammarAccess.getBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_3_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1_3__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__BoundedScope__Group_1_1_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__Group_1_1_3__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_1_3_1()); }
	(rule__BoundedScope__LowerBoundAssignment_1_1_3_1)
	{ after(grammarAccess.getBoundedScopeAccess().getLowerBoundAssignment_1_1_3_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LowerBoundedScope__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group__0__Impl
	rule__LowerBoundedScope__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getScopeKeyword_0()); }
	Scope
	{ after(grammarAccess.getLowerBoundedScopeAccess().getScopeKeyword_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group__1__Impl
	rule__LowerBoundedScope__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getAlternatives_1()); }
	(rule__LowerBoundedScope__Alternatives_1)
	{ after(grammarAccess.getLowerBoundedScopeAccess().getAlternatives_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getLowerBoundedScopeAccess().getFULL_STOPTerminalRuleCall_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LowerBoundedScope__Group_1_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group_1_0__0__Impl
	rule__LowerBoundedScope__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_0__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_0_0()); }
	(rule__LowerBoundedScope__LowerBoundAssignment_1_0_0)
	{ after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_0_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group_1_0__1__Impl
	rule__LowerBoundedScope__Group_1_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_0__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_1()); }
	LessThanSignEqualsSign
	{ after(grammarAccess.getLowerBoundedScopeAccess().getLessThanSignEqualsSignKeyword_1_0_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_0__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group_1_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_0__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_0_2()); }
	(rule__LowerBoundedScope__TypeAssignment_1_0_2)
	{ after(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_0_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__LowerBoundedScope__Group_1_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group_1_1__0__Impl
	rule__LowerBoundedScope__Group_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_1_0()); }
	(rule__LowerBoundedScope__TypeAssignment_1_1_0)
	{ after(grammarAccess.getLowerBoundedScopeAccess().getTypeAssignment_1_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group_1_1__1__Impl
	rule__LowerBoundedScope__Group_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
	GreaterThanSignEqualsSign
	{ after(grammarAccess.getLowerBoundedScopeAccess().getGreaterThanSignEqualsSignKeyword_1_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_1__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__LowerBoundedScope__Group_1_1__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__Group_1_1__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_1_2()); }
	(rule__LowerBoundedScope__LowerBoundAssignment_1_1_2)
	{ after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundAssignment_1_1_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ObjectiveDeclaration__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObjectiveDeclaration__Group__0__Impl
	rule__ObjectiveDeclaration__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDeclaration__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObjectiveDeclarationAccess().getKindAssignment_0()); }
	(rule__ObjectiveDeclaration__KindAssignment_0)
	{ after(grammarAccess.getObjectiveDeclarationAccess().getKindAssignment_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDeclaration__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObjectiveDeclaration__Group__1__Impl
	rule__ObjectiveDeclaration__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDeclaration__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObjectiveDeclarationAccess().getObjectiveAssignment_1()); }
	(rule__ObjectiveDeclaration__ObjectiveAssignment_1)
	{ after(grammarAccess.getObjectiveDeclarationAccess().getObjectiveAssignment_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDeclaration__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ObjectiveDeclaration__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDeclaration__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getObjectiveDeclarationAccess().getFULL_STOPTerminalRuleCall_2()); }
	RULE_FULL_STOP
	{ after(grammarAccess.getObjectiveDeclarationAccess().getFULL_STOPTerminalRuleCall_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__Real__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Real__Group__0__Impl
	rule__Real__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Real__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); }
	RULE_INT
	{ after(grammarAccess.getRealAccess().getINTTerminalRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Real__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Real__Group__1__Impl
	rule__Real__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Real__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRealAccess().getFullStopKeyword_1()); }
	FullStop
	{ after(grammarAccess.getRealAccess().getFullStopKeyword_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__Real__Group__2
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__Real__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Real__Group__2__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getRealAccess().getINTTerminalRuleCall_2()); }
	RULE_INT
	{ after(grammarAccess.getRealAccess().getINTTerminalRuleCall_2()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QualifiedName__Group__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QualifiedName__Group__0__Impl
	rule__QualifiedName__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_0()); }
	ruleQualifiedNameSegment
	{ after(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QualifiedName__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
	(rule__QualifiedName__Group_1__0)*
	{ after(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__QualifiedName__Group_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QualifiedName__Group_1__0__Impl
	rule__QualifiedName__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_1__0__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); }
	ColonColon
	{ after(grammarAccess.getQualifiedNameAccess().getColonColonKeyword_1_0()); }
)
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__QualifiedName__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__QualifiedName__Group_1__1__Impl
	@init {
		int stackSize = keepStackSize();
	}
:
(
	{ before(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_1_1()); }
	ruleQualifiedNameSegment
	{ after(grammarAccess.getQualifiedNameAccess().getQualifiedNameSegmentParserRuleCall_1_1()); }
)
;
finally {
	restoreStackSize(stackSize);
}


rule__ExternPredicateDeclaration__UnorderedGroup_1
	@init {
		int stackSize = keepStackSize();
		getUnorderedGroupHelper().enter(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
	}
:
	rule__ExternPredicateDeclaration__UnorderedGroup_1__0
	?
;
finally {
	getUnorderedGroupHelper().leave(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl
	@init {
		int stackSize = keepStackSize();
		boolean selected = false;
	}
:
		(
		( 
			{getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0)}?=>(
				{
					getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 0);
				}
				{
					selected = true;
				}
				(
					{ before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalAssignment_1_0()); }
					(rule__ExternPredicateDeclaration__FunctionalAssignment_1_0)
					{ after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalAssignment_1_0()); }
				)
			)
		)|
		( 
			{getUnorderedGroupHelper().canSelect(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1)}?=>(
				{
					getUnorderedGroupHelper().select(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1(), 1);
				}
				{
					selected = true;
				}
				(
					{ before(grammarAccess.getExternPredicateDeclarationAccess().getErrorAssignment_1_1()); }
					(rule__ExternPredicateDeclaration__ErrorAssignment_1_1)
					{ after(grammarAccess.getExternPredicateDeclarationAccess().getErrorAssignment_1_1()); }
				)
			)
		)
		)
;
finally {
	if (selected)
		getUnorderedGroupHelper().returnFromSelection(grammarAccess.getExternPredicateDeclarationAccess().getUnorderedGroup_1());
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__UnorderedGroup_1__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl
	rule__ExternPredicateDeclaration__UnorderedGroup_1__1?
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__UnorderedGroup_1__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ExternPredicateDeclaration__UnorderedGroup_1__Impl
;
finally {
	restoreStackSize(stackSize);
}


rule__ClassDeclaration__UnorderedGroup_0
	@init {
		int stackSize = keepStackSize();
		getUnorderedGroupHelper().enter(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
	}
:
	rule__ClassDeclaration__UnorderedGroup_0__0
	?
;
finally {
	getUnorderedGroupHelper().leave(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__UnorderedGroup_0__Impl
	@init {
		int stackSize = keepStackSize();
		boolean selected = false;
	}
:
		(
		( 
			{getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0)}?=>(
				{
					getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 0);
				}
				{
					selected = true;
				}
				(
					{ before(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0_0()); }
					(rule__ClassDeclaration__AbstractAssignment_0_0)
					{ after(grammarAccess.getClassDeclarationAccess().getAbstractAssignment_0_0()); }
				)
			)
		)|
		( 
			{getUnorderedGroupHelper().canSelect(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1)}?=>(
				{
					getUnorderedGroupHelper().select(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0(), 1);
				}
				{
					selected = true;
				}
				(
					{ before(grammarAccess.getClassDeclarationAccess().getRootAssignment_0_1()); }
					(rule__ClassDeclaration__RootAssignment_0_1)
					{ after(grammarAccess.getClassDeclarationAccess().getRootAssignment_0_1()); }
				)
			)
		)
		)
;
finally {
	if (selected)
		getUnorderedGroupHelper().returnFromSelection(grammarAccess.getClassDeclarationAccess().getUnorderedGroup_0());
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__UnorderedGroup_0__0
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__UnorderedGroup_0__Impl
	rule__ClassDeclaration__UnorderedGroup_0__1?
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__UnorderedGroup_0__1
	@init {
		int stackSize = keepStackSize();
	}
:
	rule__ClassDeclaration__UnorderedGroup_0__Impl
;
finally {
	restoreStackSize(stackSize);
}


rule__Problem__NameAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProblemAccess().getNameQualifiedNameParserRuleCall_0_1_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getProblemAccess().getNameQualifiedNameParserRuleCall_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__ImportsAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProblemAccess().getImportsImportParserRuleCall_1_0()); }
		ruleImport
		{ after(grammarAccess.getProblemAccess().getImportsImportParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Problem__StatementsAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_2_0()); }
		ruleStatement
		{ after(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__UriAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0()); }
		RULE_STRING
		{ after(grammarAccess.getUriImportAccess().getUriSTRINGTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UriImport__AliasAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getUriImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__ImportedNamespaceAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getNamespaceImportAccess().getImportedNamespaceQualifiedNameParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__NamespaceImport__AliasAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getNamespaceImportAccess().getAliasQualifiedNameParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__RangeAssignment_1_0_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); }
		ruleExpression
		{ after(grammarAccess.getAssertionOrDefinitionAccess().getRangeExpressionParserRuleCall_1_0_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__BodyAssignment_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); }
		ruleExpression
		{ after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AssertionOrDefinition__BodyAssignment_1_2_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); }
		ruleExpression
		{ after(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__FunctionalAssignment_0_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
		(
			{ before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
			Functional
			{ after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
		)
		{ after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__ErrorAssignment_0_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
		(
			{ before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
			Error
			{ after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
		)
		{ after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__ErrorAssignment_0_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
		(
			{ before(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
			Error
			{ after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
		)
		{ after(grammarAccess.getPredicateDefinitionAccess().getErrorErrorKeyword_0_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__FunctionalAssignment_0_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
		(
			{ before(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
			Functional
			{ after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
		)
		{ after(grammarAccess.getPredicateDefinitionAccess().getFunctionalFunctionalKeyword_0_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__HeadAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
		ruleCall
		{ after(grammarAccess.getPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PredicateDefinition__BodyAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
		ruleExpression
		{ after(grammarAccess.getPredicateDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__ArgumentListAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
		ruleArgumentList
		{ after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnnamedErrorPredicateDefintion__BodyAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0()); }
		ruleExpression
		{ after(grammarAccess.getUnnamedErrorPredicateDefintionAccess().getBodyExpressionParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__ExpressionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDefaultAssertionAccess().getExpressionCallParserRuleCall_1_0()); }
		ruleCall
		{ after(grammarAccess.getDefaultAssertionAccess().getExpressionCallParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DefaultAssertion__RangeAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDefaultAssertionAccess().getRangeExpressionParserRuleCall_2_1_0()); }
		ruleExpression
		{ after(grammarAccess.getDefaultAssertionAccess().getRangeExpressionParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__ResultTypeAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolCrossReference_0_0()); }
		(
			{ before(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getFunctionDefinitionAccess().getResultTypeSymbolCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__HeadAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
		ruleCall
		{ after(grammarAccess.getFunctionDefinitionAccess().getHeadCallParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__FunctionDefinition__BodyAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
		ruleExpression
		{ after(grammarAccess.getFunctionDefinitionAccess().getBodyExpressionParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeReference__TypeAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypeReferenceAccess().getTypeSymbolCrossReference_0_0()); }
		(
			{ before(grammarAccess.getTypeReferenceAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getTypeReferenceAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getTypeReferenceAccess().getTypeSymbolCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypeReference__ForceObjectTypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); }
		(
			{ before(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); }
			Object
			{ after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); }
		)
		{ after(grammarAccess.getTypeReferenceAccess().getForceObjectTypeObjectKeyword_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__KindAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0()); }
		ruleAttributeKind
		{ after(grammarAccess.getAttributeAccess().getKindAttributeKindEnumRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__TargetAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAttributeAccess().getTargetSymbolCrossReference_1_0()); }
		(
			{ before(grammarAccess.getAttributeAccess().getTargetSymbolQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getAttributeAccess().getTargetSymbolQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getAttributeAccess().getTargetSymbolCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__FunctionalAssignment_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); }
		(
			{ before(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); }
			Functional
			{ after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); }
		)
		{ after(grammarAccess.getExternPredicateDeclarationAccess().getFunctionalFunctionalKeyword_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__ErrorAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); }
		(
			{ before(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); }
			Error
			{ after(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); }
		)
		{ after(grammarAccess.getExternPredicateDeclarationAccess().getErrorErrorKeyword_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__NameAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternPredicateDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getExternPredicateDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternPredicateDeclaration__ArgumentListAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); }
		ruleArgumentList
		{ after(grammarAccess.getExternPredicateDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__ResultTypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); }
		(
			{ before(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getExternFunctionDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__NameAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getExternFunctionDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternFunctionDeclaration__ArgumentListAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); }
		ruleArgumentList
		{ after(grammarAccess.getExternFunctionDeclarationAccess().getArgumentListArgumentListParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__ResultTypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); }
		(
			{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getResultTypeSymbolCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__NameAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternAggregationOperatorDeclaration__ArgumentTypeAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolCrossReference_4_0()); }
		(
			{ before(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolQualifiedNameParserRuleCall_4_0_1()); }
		)
		{ after(grammarAccess.getExternAggregationOperatorDeclarationAccess().getArgumentTypeSymbolCrossReference_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternDatatypeDeclaration__NameAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
		ruleQualifiedName
		{ after(grammarAccess.getExternDatatypeDeclarationAccess().getNameQualifiedNameParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Expression__BodyAssignment_2_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0()); }
		ruleDisjunctiveExpression
		{ after(grammarAccess.getExpressionAccess().getBodyDisjunctiveExpressionParserRuleCall_2_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__ConditionAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0()); }
		ruleDisjunctiveExpression
		{ after(grammarAccess.getConditionalExpressionAccess().getConditionDisjunctiveExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__ThenAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0()); }
		ruleExpression
		{ after(grammarAccess.getConditionalExpressionAccess().getThenExpressionParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConditionalExpression__ElseAssignment_5
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0()); }
		ruleExpression
		{ after(grammarAccess.getConditionalExpressionAccess().getElseExpressionParserRuleCall_5_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__BindingsAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_1_0()); }
		ruleLetBinding
		{ after(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__BindingsAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_2_1_0()); }
		ruleLetBinding
		{ after(grammarAccess.getLetExpressionAccess().getBindingsLetBindingParserRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetExpression__BodyAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLetExpressionAccess().getBodyExpressionParserRuleCall_4_0()); }
		ruleExpression
		{ after(grammarAccess.getLetExpressionAccess().getBodyExpressionParserRuleCall_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__TypeAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLetBindingAccess().getTypeSymbolCrossReference_0_0()); }
		(
			{ before(grammarAccess.getLetBindingAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getLetBindingAccess().getTypeSymbolQualifiedNameParserRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getLetBindingAccess().getTypeSymbolCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLetBindingAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getLetBindingAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LetBinding__ValueAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_3_0()); }
		ruleAdditiveExpression
		{ after(grammarAccess.getLetBindingAccess().getValueAdditiveExpressionParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__ChildrenAssignment_1_0_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); }
		ruleConjunctiveExpression
		{ after(grammarAccess.getDisjunctiveExpressionAccess().getChildrenConjunctiveExpressionParserRuleCall_1_0_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__BodyAssignment_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); }
		ruleConjunctiveExpression
		{ after(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__DisjunctiveExpression__CasesAssignment_1_1_4_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); }
		ruleCase
		{ after(grammarAccess.getDisjunctiveExpressionAccess().getCasesCaseParserRuleCall_1_1_4_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Case__ConditionAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); }
		ruleConjunctiveExpression
		{ after(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Case__BodyAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); }
		ruleConjunctiveExpression
		{ after(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ConjunctiveExpression__ChildrenAssignment_1_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); }
		ruleComparisonExpression
		{ after(grammarAccess.getConjunctiveExpressionAccess().getChildrenComparisonExpressionParserRuleCall_1_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__OpAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); }
		ruleComparisonOperator
		{ after(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ComparisonExpression__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); }
		ruleAdditiveExpression
		{ after(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__OpAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); }
		ruleAdditiveBinaryOperator
		{ after(grammarAccess.getAdditiveExpressionAccess().getOpAdditiveBinaryOperatorEnumRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__AdditiveExpression__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); }
		ruleMultiplicativeExpression
		{ after(grammarAccess.getAdditiveExpressionAccess().getRightMultiplicativeExpressionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__OpAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); }
		ruleMultiplicativeBinaryOperator
		{ after(grammarAccess.getMultiplicativeExpressionAccess().getOpMultiplicativeBinaryOperatorEnumRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__MultiplicativeExpression__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
		ruleExponentialExpression
		{ after(grammarAccess.getMultiplicativeExpressionAccess().getRightExponentialExpressionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__OpAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); }
		ruleExponentialOp
		{ after(grammarAccess.getExponentialExpressionAccess().getOpExponentialOpEnumRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExponentialExpression__RightAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExponentialExpressionAccess().getRightCastExpressionParserRuleCall_1_2_0()); }
		ruleCastExpression
		{ after(grammarAccess.getExponentialExpressionAccess().getRightCastExpressionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__CastExpression__TargetTypeAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolCrossReference_1_2_0()); }
		(
			{ before(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolQualifiedNameParserRuleCall_1_2_0_1()); }
		)
		{ after(grammarAccess.getCastExpressionAccess().getTargetTypeSymbolCrossReference_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__OpAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0()); }
		ruleUnaryOperator
		{ after(grammarAccess.getUnaryExpressionAccess().getOpUnaryOperatorEnumRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__UnaryExpression__BodyAssignment_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0()); }
		ruleBracedAggregateExpression
		{ after(grammarAccess.getUnaryExpressionAccess().getBodyBracedAggregateExpressionParserRuleCall_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__OpAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAggregationAccess().getOpSymbolCrossReference_0_0()); }
		(
			{ before(grammarAccess.getAggregationAccess().getOpSymbolQualifiedNameParserRuleCall_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getAggregationAccess().getOpSymbolQualifiedNameParserRuleCall_0_0_1()); }
		)
		{ after(grammarAccess.getAggregationAccess().getOpSymbolCrossReference_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__ValueAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0()); }
		ruleExpression
		{ after(grammarAccess.getAggregationAccess().getValueExpressionParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Aggregation__ConditionAssignment_4
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); }
		ruleExpression
		{ after(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Count__ConditionAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0()); }
		ruleExpression
		{ after(grammarAccess.getCountAccess().getConditionExpressionParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Call__FunctorAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); }
		ruleReference
		{ after(grammarAccess.getCallAccess().getFunctorReferenceParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Call__ArgumentListAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
		ruleArgumentList
		{ after(grammarAccess.getCallAccess().getArgumentListArgumentListParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__ArgumentsAssignment_2_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); }
		ruleArgument
		{ after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ArgumentList__ArgumentsAssignment_2_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); }
		ruleArgument
		{ after(grammarAccess.getArgumentListAccess().getArgumentsArgumentParserRuleCall_2_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExpressionArgument__ExpressionAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0()); }
		ruleComparisonExpression
		{ after(grammarAccess.getExpressionArgumentAccess().getExpressionComparisonExpressionParserRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedVariableArgument__TypeReferenceAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); }
		ruleTypeReference
		{ after(grammarAccess.getTypedVariableArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedVariableArgument__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getTypedVariableArgumentAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__TypedStarArgument__TypeReferenceAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); }
		ruleTypeReference
		{ after(grammarAccess.getTypedStarArgumentAccess().getTypeReferenceTypeReferenceParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__ComponentsAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_0_0()); }
		rulePathComponent
		{ after(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Reference__ComponentsAssignment_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_1_1_0()); }
		rulePathComponent
		{ after(grammarAccess.getReferenceAccess().getComponentsPathComponentParserRuleCall_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__InverseAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); }
		(
			{ before(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); }
			Tilde
			{ after(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); }
		)
		{ after(grammarAccess.getPathComponentAccess().getInverseTildeKeyword_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__SymbolAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathComponentAccess().getSymbolSymbolCrossReference_1_0()); }
		(
			{ before(grammarAccess.getPathComponentAccess().getSymbolSymbolQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getPathComponentAccess().getSymbolSymbolQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getPathComponentAccess().getSymbolSymbolCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__TransitiveClosureAssignment_2_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathComponentAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0()); }
		RULE_TRANSITIVE_CLOSURE
		{ after(grammarAccess.getPathComponentAccess().getTransitiveClosureTRANSITIVE_CLOSURETerminalRuleCall_2_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__PathComponent__ReflexiveTransitiveClosureAssignment_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0()); }
		RULE_REFLEXIVE_TRANSITIVE_CLOSURE
		{ after(grammarAccess.getPathComponentAccess().getReflexiveTransitiveClosureREFLEXIVE_TRANSITIVE_CLOSURETerminalRuleCall_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__LowerBoundAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0()); }
		ruleAdditiveExpression
		{ after(grammarAccess.getIntervalAccess().getLowerBoundAdditiveExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Interval__UpperBoundAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0()); }
		ruleAdditiveExpression
		{ after(grammarAccess.getIntervalAccess().getUpperBoundAdditiveExpressionParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicLiteral__ValueAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); }
		ruleLogicValue
		{ after(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__IntLiteral__ValueAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0()); }
		RULE_INT
		{ after(grammarAccess.getIntLiteralAccess().getValueINTTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__ValueAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0()); }
		ruleReal
		{ after(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__StringLiteral__ValueAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); }
		RULE_STRING
		{ after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__AbstractAssignment_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); }
		(
			{ before(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); }
			Abstract
			{ after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); }
		)
		{ after(grammarAccess.getClassDeclarationAccess().getAbstractAbstractKeyword_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__RootAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); }
		(
			{ before(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); }
			Root
			{ after(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); }
		)
		{ after(grammarAccess.getClassDeclarationAccess().getRootRootKeyword_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__NameAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDeclarationAccess().getNameIDTerminalRuleCall_2_0()); }
		RULE_ID
		{ after(grammarAccess.getClassDeclarationAccess().getNameIDTerminalRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__SupertypesAssignment_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_1_0()); }
		(
			{ before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_1_0_1()); }
		)
		{ after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__SupertypesAssignment_3_2_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_2_1_0()); }
		(
			{ before(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolQualifiedNameParserRuleCall_3_2_1_0_1()); }
		)
		{ after(grammarAccess.getClassDeclarationAccess().getSupertypesSymbolCrossReference_3_2_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassDeclaration__FieldsAssignment_4_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getClassDeclarationAccess().getFieldsFieldParserRuleCall_4_0_1_0()); }
		ruleField
		{ after(grammarAccess.getClassDeclarationAccess().getFieldsFieldParserRuleCall_4_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__ContainmentAssignment_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); }
		(
			{ before(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); }
			Contains
			{ after(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); }
		)
		{ after(grammarAccess.getFieldAccess().getContainmentContainsKeyword_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__CrossReferenceAssignment_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); }
		(
			{ before(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); }
			Refers
			{ after(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); }
		)
		{ after(grammarAccess.getFieldAccess().getCrossReferenceRefersKeyword_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__TypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldAccess().getTypeSymbolCrossReference_1_0()); }
		(
			{ before(grammarAccess.getFieldAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getFieldAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getFieldAccess().getTypeSymbolCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__MultiplicityAssignment_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
		ruleMultiplicity
		{ after(grammarAccess.getFieldAccess().getMultiplicityMultiplicityParserRuleCall_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__NameAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldAccess().getNameIDTerminalRuleCall_3_0()); }
		RULE_ID
		{ after(grammarAccess.getFieldAccess().getNameIDTerminalRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__Field__OppositeAssignment_4_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getFieldAccess().getOppositeSymbolCrossReference_4_1_0()); }
		(
			{ before(grammarAccess.getFieldAccess().getOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getFieldAccess().getOppositeSymbolQualifiedNameParserRuleCall_4_1_0_1()); }
		)
		{ after(grammarAccess.getFieldAccess().getOppositeSymbolCrossReference_4_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactMultiplicity__ValueAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0()); }
		ruleUpperMultiplicty
		{ after(grammarAccess.getExactMultiplicityAccess().getValueUpperMultiplictyParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__LowerBoundAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedMultiplicity__UpperBoundAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); }
		ruleUpperMultiplicty
		{ after(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__NameAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEnumDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
		RULE_ID
		{ after(grammarAccess.getEnumDeclarationAccess().getNameIDTerminalRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__LiteralsAssignment_2_0_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); }
		ruleEnumLiteral
		{ after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumDeclaration__LiteralsAssignment_2_0_1_1_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); }
		ruleEnumLiteral
		{ after(grammarAccess.getEnumDeclarationAccess().getLiteralsEnumLiteralParserRuleCall_2_0_1_1_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumLiteral__NameAssignment
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0()); }
		RULE_ID
		{ after(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__TypeAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExactScopeAccess().getTypeSymbolCrossReference_1_0()); }
		(
			{ before(grammarAccess.getExactScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getExactScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1()); }
		)
		{ after(grammarAccess.getExactScopeAccess().getTypeSymbolCrossReference_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ExactScope__SizeAssignment_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0()); }
		RULE_INT
		{ after(grammarAccess.getExactScopeAccess().getSizeINTTerminalRuleCall_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__LowerBoundAssignment_1_0_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__TypeAssignment_1_0_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_0_1_0()); }
		(
			{ before(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_1_0_1()); }
		)
		{ after(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_0_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__UpperBoundAssignment_1_0_3
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_0_3_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__UpperBoundAssignment_1_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedScopeAccess().getUpperBoundINTTerminalRuleCall_1_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__TypeAssignment_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_1_2_0()); }
		(
			{ before(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_2_0_1()); }
		)
		{ after(grammarAccess.getBoundedScopeAccess().getTypeSymbolCrossReference_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__BoundedScope__LowerBoundAssignment_1_1_3_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
		RULE_INT
		{ after(grammarAccess.getBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_3_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__LowerBoundAssignment_1_0_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
		RULE_INT
		{ after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_0_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__TypeAssignment_1_0_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_0_2_0()); }
		(
			{ before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_0_2_0_1()); }
		)
		{ after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_0_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__TypeAssignment_1_1_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_1_0_0()); }
		(
			{ before(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1()); }
			ruleQualifiedName
			{ after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolQualifiedNameParserRuleCall_1_1_0_0_1()); }
		)
		{ after(grammarAccess.getLowerBoundedScopeAccess().getTypeSymbolCrossReference_1_1_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__LowerBoundedScope__LowerBoundAssignment_1_1_2
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
		RULE_INT
		{ after(grammarAccess.getLowerBoundedScopeAccess().getLowerBoundINTTerminalRuleCall_1_1_2_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDeclaration__KindAssignment_0
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
		ruleObjectiveKind
		{ after(grammarAccess.getObjectiveDeclarationAccess().getKindObjectiveKindEnumRuleCall_0_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}

rule__ObjectiveDeclaration__ObjectiveAssignment_1
	@init {
		int stackSize = keepStackSize();
	}
:
	(
		{ before(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0()); }
		ruleExpression
		{ after(grammarAccess.getObjectiveDeclarationAccess().getObjectiveExpressionParserRuleCall_1_0()); }
	)
;
finally {
	restoreStackSize(stackSize);
}